robo ntx
Post on 24-Dec-2015
2 Views
Preview:
DESCRIPTION
TRANSCRIPT
Engenharia Eletrotécnica e de Computadores
Trabalho Prático 2
Implementação de um sistema de navegação assistida por visão artificial para robôs móveis
Automação e Robótica
05-01-2015 Instituto Politécnico do Cávado e do Ave
-Tiago Valente nº 4422 - José Ruão nº 6790
TP2
Tiago Valente e José Ruão 2
1-Resumo
O presente Trabalho Prático da Unidade Curricular Automação e Robótica consiste no controlo de um
robô móvel ( kit Lego Mindstroms NTX ) com o auxilio do software MatLab para fazer o processamento
de visão por computador através de uma webcam.
Este robô móvel parte do mesmo princípio de um carro com 4 rodas, onde as rodas traseiras permitem
controlar o sentido ( para a frente ou para trás ), com determinada velocidade e as rodas da frente que
permitem a orientação do robô ( para a esquerda ou para a direita ) , através do angulo necessário para
atingir o objectivo desejado.
Numa primeira fase deste projecto, praticamos um pouco algumas funções em MatLab que permitiam
fazer este “carro” andar e virar para obtermos logo de início uma sensibilidade com este kit NTX. Posto
isto, foi implementado código MatLab e uma interface GUI para visionamento de todo o percurso que
este robô irá seguir.
Para controlar o sentido e a orientação do robô , este contem na parte superior dois círculos de cores
diferentes, um azul e um amarelo que vão fazer o controlo do carro em todo o percurso. O percurso é
constituído por círculos também , colocados no piso onde o robô circula com três cores diferentes.
O robô quando inicia o seu trajecto terá como meta o primeiro obstáculos encontrado na posição xy
contornado pela esquerda se for um obstáculo rosa ou pela direita quando verde. Depois de contornado
o primeiro obstáculo parte logo em direcção ao obstáculo seguinte e assim sucessivamente. Quando o
obstáculo for de cor vermelha o robô segue em direcção a ele , mas sem o contornar e termina a sua
trajectória a determinada distancia.
TP2
Tiago Valente e José Ruão 3
Índice
1-Resumo ...................................................................................................................................................................... 2
2-Introdução ................................................................................................................................................................. 5
3-Desenvolvimento ....................................................................................................................................................... 6
3.1 – Interface ........................................................................................................................................................... 6
3.2 – Aquisição da Imagem ....................................................................................................................................... 7
3.3 – Função Inicio .................................................................................................................................................... 8
3.3.1- Calibração das cores ................................................................................................................................... 8
3.4 – Centroids .......................................................................................................................................................... 9
3.5 – Star NTX ......................................................................................................................................................... 10
3.5.1 – Configuração do NTX .............................................................................................................................. 11
3.5.2 – Vectores – Ângulos – Distancia –Algoritmo de Viragem ........................................................................ 12
3.5.3 – Percurso .................................................................................................................................................. 20
4 - Conclusão .............................................................................................................................................................. 26
5 - Bibliografia ............................................................................................................................................................. 27
TP2
Tiago Valente e José Ruão 4
Índice de Figuras
Figura 1 – Ambiente Controlado por sistema de visão 5
Figura 2 - Interface 6
Figura 3 – Calibração dos Obstáculos 8
Figura 4 – Robô NTX 11
Figura 5 – Vectores e Angulo 14
Figura 6 – Angulou, Angulov e referencia 14
Figura 7 – distancia > 70 20
Figura 8 – distancia <70 20
Figura 9 – Contorno á direita com distancia > 150 22
Figura 10 – Contorno á direita com distancia < 150 22
Figura 11 – Velocidade = 18 24
Figura 12 – Velocidade = 8 24
Figura 13 – Fim do Percurso 25
Índice de Tabelas
Tabela 1 – Viragem do robô. 19
Tabela 2 – Contornar Obstáculo 21
Tabela 3 – Angulo Final 22
TP2
Tiago Valente e José Ruão 5
2-Introdução
Com a evolução do tempo têm surgido cada vez mais no ramo da robótica dispositivos automáticos que
são capazes de se movimentar e interagir num ambiente bem definido ao qual podemos chamar de
robô móvel. Eles possuem a capacidade de se movimentar em redor de um ambiente não estando fixos,
ao contrário de um robô industrial. Partindo deste princípio, este trabalho prático consiste num robô
móvel tipo carro.
Assim, o desenvolvimento deste projecto tem como objectivo o desenvolvimento de um algoritmo que
permite deslocar este “carro” ao longo de um percurso estabelecido por uma linha virtual que vai ser
determinada através de um sistema de visão por computador com o auxílio de uma webcam que
indicará ao robô os pontos de viragem (contornar pela esquerda - peças cor-de-rosa e contornar pela
direita – peças verdes) até alcançar o destino final (peça vermelha). Para que seja possível determinar a
posição e orientação do robô, este tem ainda na sua parte superior duas peças de cor azul e cor
amarela. Na figura 1, podemos observar o ambiente definido para este trabalho prático.
Todo este algoritmo bem como uma interface GUI foram desenvolvidos com ferramentas do MatLab.
Figura 1 – Ambiente Controlado por sistema de visão
TP2
Tiago Valente e José Ruão 6
3-Desenvolvimento
Neste capítulo vamos expor todo o desenvolvimento para a elaboração do sistema implementado. Este
encontra-se dividido em subcapítulos com o objectivo de explicar cada passo que foi efectuado ao longo
de todo o trabalho prático.
3.1 – Interface
Foi construída uma interface (figura 2) que nos vai permitir observar o trajecto do carro, a velocidade, o
angulo de viragem, a distância ao obstáculo e em que obstáculo ele se encontra. É aqui que fazemos
chamar as várias funções que vão ser tratadas nos seguintes subcapítulos através dos diversos botões.
Quando pressionamos o botão Star Vídeo, na primeira axe é exibida a imagem em tempo real, e a partir
daqui começamos a segmentar as respectivas cores correspondentes no ambiente em que o carro irá
fazer a sua trajectória.
Figura 2 - Interface
TP2
Tiago Valente e José Ruão 7
3.2 – Aquisição da Imagem
Para aquisição de vídeo utilizamos um dispositivo MJPG (webcam) e definimo-lo no comando
“vídeo.input(‘winvideo’, , ); “. Foram definidos também vários parâmetros do trigger. O “trigger =1” de
modo que em cada trigger obtivéssemos apenas uma única frame, para na fase de processamento
serem tratadas apenas uma única imagem. “Triggerreapeat, Inf” para que trigger possa ser activo
infinitamente e que a activação dele seja de forma manual.
Para o processamento da imagem, a função Inicio vai ser chamada através do último comando
mencionado na função abaixo, e podemos observar que vai ser chamada a cada 1/25 segundos.
No decorrer deste projecto tivemos grandes dificuldades na segmentação da imagem, uma vez que a
luminosidade era um dos maiores obstáculos na fase de testes e segmentação da imagem. Como
solução implementamos a função “src.Exposure = -1;” controlando a espessura da imagem.
function realVideo(handles)
NumberFrameDisplayPerSecond=25;
try
handles.video = videoinput('winvideo', 2, 'MJPG_640x480');
catch
errordlg('No webcam available');
end
src = getselectedsource(handles.video);
src.Exposure = -1;
set(handles.video,'FramesPerTrigger',1);
set(handles.video, 'FrameGrabInterval',7);
set(handles.video,'TriggerRepeat',Inf);
set(handles.video,'ReturnedColorSpace','RGB');
triggerconfig(handles.video, 'Manual');
TimerData=timer('TimerFcn', {@Inicio,handles.video,handles},'Period',1/NumberFrameDisplayPerSecond,...
TP2
Tiago Valente e José Ruão 8
3.3 – Função Inicio
A função início é chamada quando é pressionado o botão Star Vídeo. É nesta função que vamos fazer a
segmentação dos objectos que se encontram na parte superior do carro e a segmentação dos
obstáculos que vão surgir durante o percurso.
Para melhoramento de imagem foi aplicado um filtro passa-baixo com um kernel de [ 3 3 ] , em que o
pixel em análise vai fazer média com os seus pixéis vizinhos para redução do ruído.
function Inicio(hObject, event, video, handles)
trigger(video);
IM=getdata(video,1,'uint8');%lê os dados da imagem
%filtro
filtro = fspecial('average',[3 3]);
IM = imfilter(IM,filtro);
3.3.1- Calibração das cores
A calibração das cores tanto dos obstáculos como dos objectos que permitem orientar o robô é
efectuada nos sliders presentes da figura 3.
Para cada componente HSV onde H1 S1 V1 correspondem a um valor min e H2 S2 V2 ao valor máximo
os sliders vão sendo regulados até atingirmos a cor pretendida. Existe ainda um slider (Limpar) que
permite eliminar ares de desinteresse de cada cor que podem surgir durante a segmentação.
Todos estes valores podem ser guardados e posteriormente carregados num ficheiro .mat com os
botões Ler e Guardar.
Figura 3 – Calibração dos Obstáculos
TP2
Tiago Valente e José Ruão 9
Calibração da cor verde: hverde1=get(handles.slider48, 'Value'); hverde2=get(handles.slider49, 'Value'); sverde1=get(handles.slider50, 'Value'); sverde2=get(handles.slider51, 'Value'); vverde1=get(handles.slider52, 'Value'); vverde2=get(handles.slider53, 'Value'); hverde=roicolor(H,hverde1,hverde2); sverde=roicolor(S,sverde1,sverde2); vverde=roicolor(V,vverde1,vverde2); VERDE= hverde&sverde&vverde; areaverdes = get(handles.slider54, 'Value'); areaverde=round(areaverdes*1500); VERDE=bwareaopen(VERDE,areaverde); VERDE=imfill(VERDE,'holes');
Este trecho de código é referente á cor verde, mas todas as outras cores são de igual modo calibradas
correspondendo a sliders com nome diferentes destes.
3.4 – Centroids
Depois de concluída a segmentação desejada para todos as cores pertencentes a este projecto, foram
implementados os centroids de cada cor. Eles obtém-se através das coordenadas no eixo xy, que nos
permite de uma forma simples localizar os objectos no espaço.
Centroid Amarelo:
infoAm = regionprops(AMARELO,'Centroid');
for a=1 : length(infoAm)
Mam(1,1)=infoAm(a).Centroid(1,1);
Mam(1,2)=infoAm(a).Centroid(1,2);
end
Centroid Azul:
infoAz = regionprops(AZUL,'Centroid');
for a=1 : length(infoAz)
Maz(1,1)=infoAz(a).Centroid(1,1);
Maz(1,2)=infoAz(a).Centroid(1,2);
end
TP2
Tiago Valente e José Ruão 10
Centroid Obstaculos:
OBSTACULOS= ROSA + VERDE + VERMELHO;
OB = bwconncomp(OBSTACULOS);
infoObs = regionprops(OB, 'Centroid');
for o=1 : length(infoObs)
Obs(o,1)=infoObs(o).Centroid(1);
Obs(o,2)=infoObs(o).Centroid(2);
end
O centroid amarelo e azul que se encontram na parte superior do carro vão nos permitir em qualquer
instante de tempo obter a posição actual em que o robô se situa. Mam ( Marca amarela ) corresponde
ao centro amarelo e Maz ( Marca azul ) corresponde ao centro azul.
Os centroids dos Obstáculos ( Obs ), vão ser fixos durante o percurso, e correspondem a uma junção da
cor verde, rosa e vermelho. Assim o carro terá como obstáculos qualquer uma destas cores para
contornar ou parar.
3.5 – Star NTX
Neste ponto do relatório explicamos com detalhe o modo como todos os passos efectuados
anteriormente se vão processar de forma a que este robô se chame de robô em movimento. É aqui que
os centroids vão ser necessários e chamados numa função á qual designamos como “function
startntx” que permite o robô NTX seguir o seu percurso.
O botão presente na interface GUI (botão STAR NTX ) que permite o robô seguir o seu trajecto só pode
ser activo depois de uma segmentação correcta de todos as cores.
Esta função é responsável por configurar o movimento e a orientação do NTX, determinar vectores,
ângulos, distância e a forma como estes se relacionam de modo que o robô realize o seu percurso
correctamente.
function startntx(handles,video); . . . try
[Maz,Mam,Obs,infoVed,infoRo,infoVerm] = Centroids(video,handles);
catch
end point=Obs;
Como se pode observar, nesta função chamamos a função que é responsável por determinar os
respectivos centroids e que “Obs” a partir daqui vai ser chamado de “point”.
TP2
Tiago Valente e José Ruão 11
3.5.1 – Configuração do NTX
try
COM_CloseNXT all
handle=COM_OpenNXT();
COM_SetDefaultNXT(handle);
Motor_direcao = NXTMotor( MOTOR_A );
Motor_tracao = NXTMotor( MOTOR_B );
catch
end
Como configuração inicial , o COM_CloseNXT all termina ligações existentes com dispositivos NTX,
fazendo o inverso logo na função seguinte. O COM_SetDefaultNXT(handle) define o handle
anterior como global para todas as funções. De seguida são declarados os 2 motores, onde o
Motor_direcao é responsável por controlar a direcção e o Motor_tracao é responsável por
determinar o sentido e velocidade do robô.
A figura 4, legenda estes dois motores e também o posicionamento dos respectivos objectos colocados
na parte superior do carro.
Figura 4 – Robô NTX
TP2
Tiago Valente e José Ruão 12
3.5.2 – Vectores – Ângulos – Distancia –Algoritmo de Viragem
Neste ponto do relatório explicamos detalhadamente os vectores, os ângulos, a distância e a forma
como estes se vão relacionar de modo a conseguirmos em qualquer situação onde o carro se encontre,
para onde se deve orientar e seguir de forma coerente o respectivo obstáculo.
Esta foi de facto a fase do trabalho prático que mais se tornou complicada no decorrer do mesmo.
Após culminar esta fase, podendo mesmo dizer que deixou de ser critica e até bastante intuitiva,
prosseguimos então com trechos de código referentes a este tópico do trabalho prático.
Vectores
O código seguinte refere-se aos vectores principais que foram utilizados. O vector v diz respeito ao
vector que se encontra em cima do carro ( ponto azul atrás e ponto amarelo á frente ). Este vector tem
a funcionalidade de “guia” do carro, ele é que nos vai dizer em que situação é que o carro se encontra.
Posto isto, o vector u ( ponto azul em cima do carro e ponto que se vai atingir), foi implementado para
que existisse relação com o vector v. De uma forma geral , o vector v onde quer que se encontre terá
como objectivo aproximar-se do vector u para que o carro siga correctamente o ponto a atingir.
v(1,1)=(Mam(1,1)-Maz(1,1)); v(1,2)=(Mam(1,2)-Maz(1,2));
u(1,1)=(point(x,1)-Maz(1,1)); u(1,2)=(point(x,2)-Maz(1,2));
Angulo (A)
Este angulo é referente ao angulo entre o vector u e v e é com ele que vamos fazer o carro virar á
esquerda ou á direita consoante a situação onde estes se encontrem.
angulo = acos((u(1,1)*v(1,1)+u(1,2)*v(1,2))/(sqrt((u(1,1)^2)+... (u(1,2)^2))*sqrt((v(1,1)^2)+(v(1,2)^2))))*180/pi;
TP2
Tiago Valente e José Ruão 13
Distancia
Foi referenciada a distancia neste subcapítulo, porque é a partir deste que conseguimos perceber de
onde ela surge. Como se pode observar ela surge a partir do vector u, que é o ponto azul que se
encontra atras do carro e o ponto que se vai atingir. A distância é importantíssima neste projecto para
nos relacionarmos em que situação o carro deixa de prosseguir um ponto e atingir de imediato o ponto
seguinte. Ela é usada frequentemente em todo o percurso até atingir o obstáculo final.
distancia=sqrt(u(1,1)^2+u(1,2)^2);
Algoritmo de Viragem
Depois de implementados os vectores e o angulo entre eles, é neste fase que vamos explicar
detalhadamente na tabela 1, o modo como o vector v se deve aproximar do vector u até atingir o
mínimo angulo possível ( 0 graus) .
Foram analisados os 16 casos possíveis da tabela, cada um com situações todas diferente, mas com a
mesma finalidade, ou vira á esquerda ou vira á direita. O vira á direita diz respeito ao próprio angulo e o
vira á esquerda diz respeito ao próprio angulo mas invertido.
Ao longo deste estudo, a forma como o angulo deveria ser positivo ou negativo tornou-se complicada
em 4 situações, sendo estas, situações em que os pontos a atingir e o ponto de cima do carro se
encontram no mesmo quadrante. Como solução para estes 4 casos foi necessário implementar uma
“referência” no eixo dos xx, e implementar 2 ângulos secundários, mas de uma extrema importância
para estas 4 situações. Seguem-se de seguida o angulou (Au) que é o angulo entre a referência do ponto
azul traçada em x e o vector u, e o angulov (Av) que é o angulo entre a mesma referencia e o vector v.
Foi ainda feita uma variável ‘diferenca’ que faz a diferença entre os ângulos secundários .
Au: angulou = acos((u(1,1)*referencia(1,1)+u(1,2)*referencia(1,2))/...
(sqrt((u(1,1)^2)+(u(1,2)^2))*sqrt((referencia(1,1)^2)+(referencia(1,2)^2))))... *180/pi;
Av: angulov = acos((v(1,1)*referencia(1,1)+v(1,2)*referencia(1,2))/...
(sqrt((v(1,1)^2)+(v(1,2)^2))*sqrt((referencia(1,1)^2)+(referencia(1,2)^2))))... *180/pi;
diferenca=angulou-angulov;
TP2
Tiago Valente e José Ruão 14
As imagens 5 e 6 legendam de uma forma geral todos os quadrantes , os pontos azul, amarelo e
obstáculo, os vectores u e v, o angulo (A), a referencia e os ângulos angulou (Au) e angulov (Av).
Figura 5 – Vectores e Angulo
Figura 6 – Angulou, Angulov e referencia
TP2
Tiago Valente e José Ruão 15
Caso Imagem MatLab
u(+,+)
v(+,+)
if diferenca < 0 angulo=-angulo;
elseif diferenca > 0 angulo=angulo; end
u(+,+)
v(+,-)
angulo=angulo;
u(+,+)
v(-,+)
angulo=-angulo;
TP2
Tiago Valente e José Ruão 16
u(+,+)
v(-,-)
if angulou>45 && angulov>135 angulo=-angulo;
elseif angulou>45 && angulov<135 angulo=angulo;
elseif angulou<45 && angulov>135 angulo=-angulo;
elseif angulou<45 && angulov<135 angulo=angulo; end
u(+,-)
v(+,+)
angulo=-angulo;
u(+,-)
v(+,-)
if diferenca < 0
angulo=angulo;
elseif diferenca > 0
angulo=-angulo; end
TP2
Tiago Valente e José Ruão 17
u(+,-)
v(-,+)
if angulou>45 && angulov>135 angulo=-angulo;
elseif angulou>45 && angulov<135 angulo=angulo;
elseif angulou<45 && angulov>135 angulo=angulo;
elseif angulou<45 && angulov<135 angulo=-angulo; end
u(+,-)
v(-,-)
angulo=angulo;
u(-,+)
v(+,+)
angulo=angulo;
TP2
Tiago Valente e José Ruão 18
u(-,+)
v(-,+)
if diferenca <0 angulo=-angulo;
elseif diferenca >0 angulo=angulo; end
u(-,+)
v(-,-)
angulo=angulo;
u(-,-)
v(+,-)
angulo=-angulo;
TP2
Tiago Valente e José Ruão 19
Tabela 1 – Viragem do robô.
u(-,-)
v(-,+)
angulo=-angulo;
u(-,-)
v(-,-)
if diferenca >0 angulo=-angulo;
elseif diferenca <0 angulo=angulo; end
TP2
Tiago Valente e José Ruão 20
3.5.3 – Percurso
Um ciclo infinito permite percorrer todos os pontos do percurso, em que x é inicializado a 1 e
incrementa +1 a cada obstáculo detectado. Inserido nele, ainda existe um outro ciclo “while” que vai
controlar o incremento deste x.
point=Obs;
for x=1 : length(point(:,1))
.
.
.
while (1)
if (distancia<70 );
break
end
.
.
.
end
end
O robô quando inicia o seu percurso segue em direcção ao primeiro obstáculo encontrado e passa para
o obstáculo seguinte quando a distância é menor que 70. Assim, enquanto que a distancia for maior que
70 o carro só tem como objectivo seguir em direcção ao obstáculo mais próximo de si.
As figuras 7 e 8 demonstram como isso acontece em tempo real, quando a distância é superior a 70 e
quando é inferior a 70.
Figura 7 – distancia > 70 Figura 8 – distancia <70
TP2
Tiago Valente e José Ruão 21
Contornar Obstáculos:
O carro quando detecta um obstáculo, vai identificar a sua cor para fazer um contorno pela esquerda
quando é cor-de-rosa ou pela direita quando é cor verde.
Raio=get(handles.Sliderraio, 'Value');
raio=40+Raio*200;
VERDES
if (point(x,1) == infoVed(1).Centroid(1,1)) &&( distancia<150)
point(x,1)=(infoVed(1).Centroid(1,1))-raio;
point(x,2)=(infoVed(1).Centroid(1,2))+raio;
end
ROSA
if (point(x,1) == infoRo(1).Centroid(1,1)) &&( distancia<150)
point(x,1)=(infoRo(1).Centroid(1,1))-raio;
point(x,2)=(infoRo(1).Centroid(1,2))-raio;
end
Na tabela 2, podemos observar que o obstáculo se for verde o point vai assumir um valor – raio em x e
+ raio em y, ou se for cor-de-rosa – raio em x e – raio em y.
Tabela 2 – Contornar Obstáculo
O valor do “raio” pode ser alterado num slider, permitindo poder alterar o seu valor. Por convenção
definiu-se um valor inicial de raio = 40.
Estes contornos não acontecem durante todo o percurso, a distância também tem influência neste
conjunto de “if´s”. Assim só a determinada distância é que este raio é chamado para determinar um
point auxiliar. Na figura 9 e 10, temos o caso quando o robô tem de contornar á direita ( obstáculo verde
) e a relação com a distancia, isto é, se distancia < 150 o carro segue em direcção ao point auxiliar, caso
contrario segue em direcção ao centro do obstáculo .
Contorna pela direita Contorna pela esquerda
TP2
Tiago Valente e José Ruão 22
Figura 9 – Contorno á direita com distancia > 150 Figura 10 – Contorno á direita com distancia < 150
Motor direcção:
Para determinar o angulo que o motor irá virar, estabeleceu-se um angulo final que calcula a diferença
do angulo até aqui calculado com o angulo actual do motor (Angulo_rodas). A função
“ReadFromNXT()” permite identificar a posição actual em que o motor se encontra. Assim a variável
angulo_Final vai ser a o angulo que o carro terá de efectuar para o correcto movimento do carro.
A tabela 3 exemplifica o caso quando o angulo final é positivo e/ou negativo.
Angulo_rodas=Motor_direcao.ReadFromNXT().Position;
angulo_Final = angulo-Angulo_rodas
Angulo Final Positivo Angulo Final Negativo
11 = 35 – (Angulo_rodas)
Angulo_rodas = 24
–22 = –46 – (Angulo_rodas)
Angulo_rodas = –24 Tabela 3 – Angulo Final
TP2
Tiago Valente e José Ruão 23
Ainda na configuração deste motor , este angulo final vai ser limitado. Na trecho seguinte podemos
verificar que se o ângulo final ultrapassar os -40°, angulo final será no máximo -40° de rodagem e se
angulo final ultrapassar os 40°, angulo final será no máximo 40° de rodagem. Isto é importante em casos
que se o angulo final atingir valores aos quais a rodagem do motor de direcção não consiga suportar.
Este robô também possui um limite de brecagem tal como o de um automóvel e por isso esta função
permite que esse limite não seja atingido.
if(angulo_Final<-40)
angulo_Final=-40;
elseif(angulo_Final>40)
angulo_Final=40;
end
A função seguinte permite-nos definir o sentido do motor de direcção. Se o angulo final assumir um
valor negativo o sentido do motor também é negativo. Se o angulo final assumir um valor positivo, o
sentido do motor também é positivo. O -50 e o 50 é a velocidade com que o motor vira num sentido ou
no sentido oposto.
if (angulo_Final<0)
Motor_direcao.Power = -50;
else
if(angulo_Final>0)
Motor_direcao.Power = 50;
else
Motor_direcao.Power = 0;
end
end
No comando Motor_direcao.TachoLimit indicamos o angulo final de rodagem como o numero
de pontos que o motor vai rodar. Como este comando apenas aceita valores inteiros e positivos
utilizou-se o comando “ round” e “abs”.
Motor_direcao.TachoLimit = round(abs(angulo_Final))+1;
TP2
Tiago Valente e José Ruão 24
Motor tracção:
O motor de tracção para este projecto apenas terá um sentido, o sentido positivo. Aqui a distância
também tem influência na determinação da velocidade do robô. Nas figuras 11 e 12, observamos que
quando o carro se aproxima de um obstáculo a velocidade diminui.
velocidade=0;
if(distancia>150)
velocidade=18;
else
velocidade=8;
end
Motor_tracao.Power = round(velocidade)+1;
Figura 11 – Velocidade = 18 Figura 12 – Velocidade = 8
Quando a distancia é superior a 150 a velocidade do robô é de 18 e quando a distancia for menos que
50 a velocidade é 8.
TP2
Tiago Valente e José Ruão 25
Fim do Percurso:
O fim do percurso acontece quando o obstáculo detectado for da cor vermelha e a distância a este
atingir os 100 pixéis.
if (point(x,1) == infoVerm(1).Centroid(1,1)) && distancia <100
try
Motor_tracao.Power = 0;
Motor_tracao.SendToNXT()
Motor_direcao.Power = 0;
Motor_direcao.TachoLimit = 0;
Motor_tracao.TachoLimit = 0;
Motor_tracao.SendToNXT()
catch
end
end
Figura 13 – Fim do Percurso
Como podemos observar na figura 13, quando é detectado o obstáculo vermelho ele não é contornado,
e a uma distância inferior a 100 terminamos assim o percurso do robô do kit NTX tipo carro.
TP2
Tiago Valente e José Ruão 26
4 - Conclusão
Concluído este trabalho prático, o grupo sente que os objectivos propostos para a realização do mesmo
são bastante satisfatórios. O robô consegue efectuar todo o percurso, contornando os obstáculos
correctamente e quando chega ao último obstáculo termina a sua rota como pedido no enunciado.
Foram muitas as dificuldades sentidas na realização deste projecto. Foi necessário uma extra dedicação
para conseguir fazer com que o robô conseguisse realizar o seu percurso, podendo mesmo afirmar que
este foi o projecto académico que mais tempo nos “roubou” não só pela forma como deveríamos
implementar código mas também por culpa de certos factores que foram surgindo. A forma como este
robô deveria virar e para onde virar foi o principal obstáculo. Um outro obstáculo que nos surgiu quase
sempre na fase de testes foi a iluminação inconstante na área de inspecção, fazendo com que os
objectos colocados em cima do carro desaparecessem e fazia com que o percurso não terminasse.
Como solução para este obstáculo, utilizamos uma função que permitiu regular a espessura da imagem
real ficando com uma imagem mais estável em toda a área de inspecção.
Com a finalização deste projecto, ao tempo que lhe chamamos “roubado”, podemos chamar-lhe antes
tempo ganho , pois é com grande satisfação nossa que concluímos um projecto que permite um robô
móvel deslocar-se num ambiente definido.
top related