Robo NTX

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


Í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


Í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


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


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


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


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


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


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


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


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


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


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


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


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


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


u(-,+)

v(-,+)

if diferenca <0 angulo=-angulo;

elseif diferenca >0 angulo=angulo; end

u(-,+)

v(-,-)

angulo=angulo;

u(-,-)

v(+,-)

angulo=-angulo;

TP2


Tabela 1 – Viragem do robô.

u(-,-)

v(-,+)

angulo=-angulo;

u(-,-)

v(-,-)

if diferenca >0 angulo=-angulo;

elseif diferenca <0 angulo=angulo; end

TP2


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


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


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


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


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


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


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.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


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.

TP2


5 - Bibliografia

- Diapositivos fornecidos pelo Docente nas aulas

- http://www.mathworks.com/products/matlab/examples.html

- http://pt.wikipedia.org/wiki/Rob%C3%B4_m%C3%B3vel

Robo NTX

Documents

Transcript of Robo NTX