Implementação de um robot móvel

i
Engenharia Eletrotécnica e de Computadores
Implementação de um
Robot Móvel
Automação e Robótica
07-01-2013
Instituto Politécnico do Cávado e do Ave
Luís Pais nº6633 / Paulo Lima nº6522

Implementação de um Robot Móvel
Agradecimentos
Agradece-se ao docente António Moreira, que lecionou a unidade curricular de
“Automação e Robótica” no Instituto Politécnico do Cávado e do Ave os
conhecimentos adquiridos ao longo do semestre e que foram fundamentais para a
elaboração deste projeto.
De igual modo salienta-se o espirito de entreajuda dos colegas de curso de
engenharia eletrotécnica e computadores (pós laboral), que ao longo da fase de
projeto possam ter ajudado, tanto com ideias, tanto com sentido crítico o que
permitiu atingir os resultados finais apresentados neste mesmo relatório.

Resumo
O objetivo deste trabalho prático e de laboratório foi o desenvolvimento de um
algoritmo em Matlab que permitisse deslocar um Robot Móvel ao longo de um
percurso pré estabelecido por uma linha preta.
Ao longo deste percurso, o Robot seria confrontado com um conjunto de obstáculos,
em que para a superação dos mesmos, o robot deveria estabelecer uma trajetória
que lhe permitisse contornar o obstáculo e retornar o percurso pré definido pela
linha.
Para isso foi utilizado o Robot Móvel da LEGO MINDSTORMS NXT, pelo que se tornou
necessário conhecer as características próprias associadas a este tipo de Robots e
consequente tipo de programação, bem como manipular os fatores externos que
afetam o seu correto funcionamento.
Parte do trabalho, para além de programar o Robot em Matlab, foi otimizar o seu
funcionamento como será descrito posteriormente neste relatório.

Índice
Agradecimentos ...........................................................................................................iii
Resumo ..........................................................................................................................v
Índice...........................................................................................................................vii
1 Introdução.............................................................................................................1
1.1 Objetivos.................................................................................................................. 1
1.2 Caraterísticas do Robot LEGO MINDSTORMS NXT................................................. 2
1.2.1 Caraterísticas técnicas ......................................................................................................2
1.3 Descrição dos componentes ................................................................................... 2
1.3.1 Servomotores ...................................................................................................................3
1.3.2 Sensor de cor ....................................................................................................................4
1.3.3 Sensor de ultrassom .........................................................................................................4
1.3.4 Controlo de estrutura .......................................................................................................5
1.4 Linguagem de Programação.................................................................................... 6
2 Contexto.................................................................................................................7
3 Descrição técnica...................................................................................................8
3.1 Código do programa................................................................................................ 8
3.2 Comentários ao código do programa ................................................................... 10
3.3 Imagens do Robot NXT.......................................................................................... 14
4 Conclusões ...........................................................................................................16
Bibliografia ..................................................................................................................19

Índice de Figuras
Figura 1 - Esquema da trajetória a seguir pelo robot móvel._________________________________1
Figura 2 - Imagem de um robot LEGO MINDSTORMS NXT. ________________________________2
Figura 3 - Localização de um dos servomotores presentes no robot. ___________________________3
Figura 4 - Imagem de um servomotor (NXT User Guide). ___________________________________3
Figura 5 - Sensor de cor presente no robot. ______________________________________________4
Figura 6 - Sensor de ultrassom presente no robot. _________________________________________5
Figura 7 - Imagem de um Smart Brick (NXT Web Site). _____________________________________5
Figura 8 - Primeira abordagem adotada ________________________________________________7
Figura 9 - Fotografia do robot utilizado. _______________________________________________14
Figura 10 - Imagem em perspetiva do robot utilizado. _____________________________________14
Figura 11 - Imagem do robot seguindo a linha definida. ___________________________________15
Figura 12 - Imagem do robot a desviar-se do objeto.______________________________________15

Notação e Glossário
LABVIEW Laboratory Virtual Instrument Engineering Workbench.
MATLAB
Lego Mindstorms NXT
Matrix Laboratory software.
Linha do brinquedo LEGO
RWTH Aachen Mindstorms toolbox Toolbox developed to control LEGO® MINDSTORMS® NXT
robots with MATLAB

Luís Pais / Paulo Lima 1
1 Introdução
1.1 Objetivos
 Desenvolver em Matlab um algoritmo de seguimento de linha (Estratégia de
Controlo de Movimento): O Robot Móvel deve seguir uma linha preta pré
estabelecida.
 Desenvolver em Matlab um algoritmo para contornar obstáculos (Estratégia
de Controlo de Movimento): Quando confrontado com um obstáculo, o
Robot deve estabelecer uma trajetória alternativa e retomar a trajetória
original assim que seja possível.
 Realização do percurso sem falhas: A programação deve ser efetuada de tal
modo que o Robot seja capaz de efetuar o percurso com o mínimo de erro
possível.
 O percurso deverá ser realizado no menor tempo possível: A programação
deve ser otimizada de modo que o Robot seja capaz de efetuar o percurso no
menor tempo possível.
Figura 1 - Esquema da trajetória a seguir pelo robot móvel.

1.2 Caraterísticas do Robot LEGO MINDSTORMS NXT
A LEGO MINDSTORMS NXT é uma linha de brinquedos, fabricados pela LEGO, criada
para a educação tecnológica. Possui aplicações na área da automação, robótica,
controlo, física e matemática.
1.2.1 Caraterísticas técnicas
 Processador ATMEL 32 Bit ARM.
 3 Portas de saída digital.
 4 Portas de entrada sendo uma do tipo IEC 61158 tipo 4.
 Display do tipo matriz.
 Altifalante.
 Bateria recarregável de lítio.
 Bluetooth.
 Porta de comunicação USB 2.0.
 3 Servomotores interativos com encoderes acoplados.
 Sensor de ultrassom, som, luz, cor e contato.
 O Software é uma versão LEGO do LABVIEW.
1.3 Descrição dos componentes
O Robot utilizado no trabalho possui uma série de mecanismos fundamentais ao seu
funcionamento que serão descritos em seguida.
Figura 2 - Imagem de um robot LEGO MINDSTORMS NXT.

1.3.1 Servomotores
O servomotor é um tipo de máquina elétrica, em que o seu movimento é
proporcional ao comando que lhe é fornecido. Ao contrário dos motores
convencionais, em vez de rodar ou de se mover livremente, o servomotor apresenta
um controlo efetivo da sua posição, devido ao fato de se tratar de um dispositivo
que atua em malha fechada. Assim, recebe um sinal, verifica a sua posição atual e
depois atua no sistema para se deslocar para a posição pretendida.
Os servomotores servem para fazer mover o robot, possuindo encoderes
incorporados (sensor de rotação), o que lhe permite um perfeito controlo e precisão
sobre o seu movimento.
Figura 3 - Localização de um dos servomotores presentes no robot.
Figura 4 - Imagem de um servomotor (NXT User Guide).

1.3.2 Sensor de cor
O sensor de cor irá funcionar como a visão do Robot, sendo que este sensor que se
encontra montado neste aparelho é capaz de distinguir 6 cores diferentes, através
da análise das suas intensidades.
Será assim que o Robot será capaz de seguir o trajeto, assinalado por uma linha
preta, diferenciando-a do restante espaço envolvente que terá uma cor
predominantemente branca.
Figura 5 - Sensor de cor presente no robot.
1.3.3 Sensor de ultrassom
Este sensor tem como objetivo analisar o espaço que o rodeia. O seu princípio de
funcionamento é simples sendo equiparado a um radar. O sensor envia um sinal e
aguarda o seu retorno.
Existe uma melhor receção do sinal quando qualquer objeto ou obstáculo detetado
se encontra em frente ao sensor, havendo perda de eficácia se o objeto ou obstáculo
se encontrar em perímetros mais laterais.
O sensor de ultrassom mede igualmente a sua distância (logo a do Robot)
relativamente ao objeto/obstáculo.

Figura 6 - Sensor de ultrassom presente no robot.
1.3.4 Controlo de estrutura
O controlador de estrutura (ou Smart Brick) é a central que faz com que seja possível
o Robot funcionar.
É nesta estrutura que são ligados os sensores, motores e onde é possível carregar a
programação que define os parâmetros para o Robot.
Possui 4 portas de entrada, onde se encontram ligados os dois sensores (cor,
ultrassom) e 3 saídas onde estarão ligados os três servomotores para a consequente
locomoção do Robot. Tem uma porta USB por onde são comunicados os dados de
programação, neste caso provenientes do MATLAB.
Figura 7 - Imagem de um Smart Brick (NXT Web Site).

1.4 Linguagem de Programação
Para a programação deste trabalho vai-se recorrer à linguagem de programação
MATLAB.
Esta é uma ferramenta de programação de alto nível vocacionada originalmente
para o cálculo numérico, uma vez que integra análise numérica, cálculo com
matrizes, processamento de sinais e construção de gráficos.
A simplicidade de funcionamento do MATLAB permite a resolução de problemas
numéricos em menor tempo do que se gastaria para escrever um programa
semelhante noutras linguagens.
O programa dispõe ainda de diversas extensões, chamadas TOOLBOXS, e é possível
incluir bibliotecas, sendo que para a elaboração deste projeto será necessário
indexar uma denominada “Matlab RWTHMindstormsNXTv4.07”, que foi criada para
controlo destes Robots da LEGO.
O interface entre o MATLAB e o Robot será efetuado através de cabo USB 2.0.

2 Contexto
A estratégia para a elaboração deste trabalho foi estruturar o trabalho em etapas e
avançar progressivamente. Assim, os códigos de programação foram sucessivamente
trabalhados até se atingir a versão final que respeitasse todos os parâmetros
pretendidos. Inicialmente criou-se apenas um código que permitisse o robot seguir a
linha sem contar com mais nenhum fator externo.
Figura 8 - Primeira abordagem adotada
Na figura 8 é possível verificar a forma que o robot utilizava para seguir a linha no
primeiro método. Uma das rodas rodava sempre a velocidade constante e a outra
roda acelerava ou parava mediante o valor lido pelo sensor de luz. Caso fosse baixo o
valor lido acelerava essa roda até encontrar o valor máximo e desta forma andava
sempre em ziguezague sobre a linha a acompanhar a trajetória.
Numa segunda fase modificou-se o código de modo a sintonizar um PID para
controlo dos motores de modo ao robot responder de forma mais eficaz.
Por último e de modo a que todos os requisitos fossem atendidos, foi criada a parte
do programa de modo que o Robot conseguisse prever, evitar obstáculos e retomar
o mais brevemente possível a sua trajetória definida.
Ao longo deste processo conseguiu-se igualmente melhorar todo o programa e ir
reduzindo gradualmente as linhas de código necessárias para o programa funcionar.

3 Descrição técnica
3.1 Código do programa
%%Limpa o workspace.
clear all
clc
COM_CloseNXT('all') % fecha e limpa todos os NXT devices existentes
close all
%%OpenNXT
ComNXT = COM_OpenNXT(); % Tenta abrir uma conexão via USB. O primeiro dispositivo
NXT a ser encontrado será usado.
COM_SetDefaultNXT(ComNXT); % Define o valor por defeito global do COM_SetDefaultNXT.
%% Configuracao do NXTMotor
l_wheel = NXTMotor( MOTOR_A ); % Configura a roda esquerda com o motor A
r_wheel = NXTMotor( MOTOR_C ); % Configura a roda direita com o motor C
l_wheel.SmoothStart = true; % Acelera suavemente o movimento do motor
r_wheel.SmoothStart = true;
%% Abre o sensor de Luz com a Luz Vermelha
OpenNXT2Color( SENSOR_1, 'RED' )
%% Abre o sensor de Ultrasonic
OpenUltrasonic( SENSOR_2 )
%% Configuracao do PID para controlo dos motores
Kp = 0.7; %O KP e Kp*100 na realidade sera 70
Ki = 0.001; %O Ki e Ki*100 na realidade sera 0,1
Kd = 0.4; %O Kd e Kd*100 na realidade sera 40 %4
offset = 330; %Initializa a variavel de offset % estava a 320 sala automacao
Tp = 25; %Velocidade dos motores das rodas % 27 e 29 ok!
integrativo = 0; %A variavel temporaria que vai guardar o valor do integrativo
lastError = 0; %A variavel temporaria que vai guardar o valor do erro
derivativo = 0; %A variavel temporaria que vai guardar o valor do derivativo
%% Ciclo que segue a linha utilizando os valores do PID
while ~strcmp( GetNXT2Color( SENSOR_1 ), 'RED' )
ValorLuz = GetNXT2Color(SENSOR_1)
erro = ValorLuz - offset; % calcula o erro ao
subtrair o offset
integrativo = integrativo + erro; % calcula o integrativo
derivativo = erro - lastError; % calcula o derivativo
Turn = (Kp*erro) + (Ki*integrativo) + (Kd*derivativo); % O "termo P", "termo I"
e o "termo D"
Turn = Turn/5; % Divide o valor
calculado atras por 6
l_wheel.Power = floor(Tp + Turn); % O nivel de Power do
motor A
r_wheel.Power= floor(Tp - Turn); % O nivel de Power do
motor C
l_wheel.SendToNXT();
r_wheel.SendToNXT();
lastError = erro; % Salva o valor do
erro atual
%% Ciclo que deteta objeto, desvia-se, volta a linha e retoma a posicao
dst = GetUltrasonic( SENSOR_2 ); % Detecta se tem objeto em frente para se
desviar
if (dst < 25) % Valor a partir do qual ele para ao detetar
objeto %tinha 22 sala automacao
l_wheel.Stop('off'); % Para as rodas
r_wheel.Stop('off');
l_wheel.Power = -25; % Roda 90 graus para Esquerda
r_wheel.Power = 25;
l_wheel.TachoLimit = 275; % Graus que viram os motores
r_wheel.TachoLimit = 275;

l_wheel.SendToNXT(); % Envia os valores de tras para os motores
r_wheel.SendToNXT();
l_wheel.WaitFor(); % Espera que os valores do TachoLimit sejam
atingidos
r_wheel.WaitFor();
motorSensor = NXTMotor( MOTOR_B, 'Power', -50); % Roda o motor do sensor
ultrasom com velocidade -50
motorSensor.TachoLimit = 60; % Graus que vira o motor do
sensor ultrasom para se obter 45graus
motorSensor.SmoothStart = true; % Faz com que o motor inicie
com uma acelaracao suave
motorSensor.SendToNXT(); % Envia os valores de tras
para os motores
motorSensor.WaitFor(); % Espera que os valores do
TachoLimit sejam atingidos
% Contorna o objecto pela direita
encontralinha = 1; % Vai contornando o objeto
ate encontrar a linha
while (encontralinha)
l_wheel.TachoLimit = 0;
r_wheel.TachoLimit = 0;
l_wheel.Power = 25; % Velocidade para fazer o
contorno do objeto R. Esq.%22 sala automacao
r_wheel.Power = 10; % Velocidade para fazer o
contorno do objeto R. Dir. %10 sala automacao
l_wheel.SendToNXT() % Envia os valores de tras
para os motores
r_wheel.SendToNXT()
temp = GetNXT2Color(SENSOR_1);
dst = GetUltrasonic( SENSOR_2 );
while dst < 23
l_wheel.Power = 10; % Velocidade para fazer o contorno
do objeto R. Esq.%22 sala automacao
r_wheel.Power = 45; % Velocidade para fazer o contorno
do objeto R. Dir. %10 sala automacao
l_wheel.SendToNXT() % Envia os valores de tras para os
motores
r_wheel.SendToNXT()
dst = GetUltrasonic( SENSOR_2 );
end
if (temp < 200) % Valor mais central possivel (205)
encontralinha = 0; % Quando encontrar na linha o valor de
205, para
end
end
l_wheel.Stop('off'); % Para as rodas
r_wheel.Stop('off');
motorSensor = NXTMotor( MOTOR_B, 'Power', 50); % Roda o motor do sensor
ultrasom com velocidade 50
motorSensor.TachoLimit = 60; % Graus que vira o motor do
sensor ultrasom para restabelecer a posicao inicial
motorSensor.SendToNXT(); % Envia os valores de tras
para os motores
motorSensor.WaitFor(); % Espera que os valores do
TachoLimit sejam atingidos
% l_wheel.TachoLimit = 0; % Quando
TachoLimit e zero, roda infinitamente
% r_wheel.TachoLimit = 0;
l_wheel.Power = -5; % Velocidade da R. Esq. para
restabelecer posicao depois de encontar a linha - 30/1o teste / -40/2o teste +rapido
ok
r_wheel.Power = 6; % Velocidade da R. Esq. para
restabelecer posicao depois de encontar a linha - 50/1o teste / 60/2o teste +rapido ok
l_wheel.SendToNXT() % Envia os valores de tras
para os motores para o carro endireitar
r_wheel.SendToNXT()

while (GetNXT2Color(SENSOR_1)<461) % Restabelece a posicao ate
encontrar o valor 461. Prossegue normalmente depois de encontrar. % 420 sala automacao
end
pause(0.5)
end
%Coloca as variaveis temporarias do PID a zero para inicializar mais corretamente
o arranque depois de encontrar de novo a linha
integrativo = 0; %A variavel temporaria que vai guardar o valor do integrativo
e inicializada a zero
ultimoErro = 0; %A variavel temporaria que vai guardar o valor do erro e
inicializada a zero
derivativo = 0; %A variavel temporaria que vai guardar o valor do derivativo e
inicializada a zero
end % Feito o loop, volta a cima e reinicia tudo de novo!
3.2 Comentários ao código do programa
No início do código do programa, utilizam-se alguns comandos para limpar “lixo” que
possa existir no MATLAB, e configurar a ligação USB para se utilizar o robot NXT.
Neste trecho do código, realizam-se as configurações dos motores e dos sensores
utilizados, o de luz e o ultrassónico.

Neste módulo do código anterior, faz-se a inicialização dos valores a serem utilizados
nos cálculos matemáticos para a utilização do PID no controlo da velocidade dos
motores. Os valores encontrados foram calibrados em modo tentativa erro.
Verificámos que as condições se alteram cada vez que tentámos ensaiar os valores já
calibrados anteriormente. Notámos que o desgaste das pilhas e as condições de
iluminação alteravam significativamente os resultados finais e a respetiva resposta
do PID ao comportamento da mesma pista. De qualquer, forma estas diferenças
seriam mais notáveis ao tentarmos os limites de máximo comportamento
pretendidos. Caso reduzíssemos os valores para velocidades e reações menores já
não se notava tantas diferenças no seu comportamento.
Este é o ciclo onde se inicia o processo de seguimento da linha. O código seguinte
será o responsável por seguir a linha.
O código anterior mostra os cálculos matemáticos para a configuração do PID a
aplicar aos motores. Inicialmente, a primeira versão de código que elaborámos, não
utilizava PID. Simplesmente seguia a linha através dos valores máximos e mínimos
estabelecidos e lidos pelo sensor de luz. Apesar de funcional, com as variações que já
comentámos atrás, tornava-se muito instável na realização das curvas. Algumas
vezes fazia corretamente as curvas outras já não as conseguia fazer. Ao
implementarmos o código de controlo dos motores por PID, essa dificuldade foi
ultrapassada e o contorno da linha com o robot tornou-se mais estável com
velocidades superiores.

Ciclo onde se verifica se existe algum obstáculo. Caso exista, o robot vai contornar o
objeto pela direita até encontrar de novo a linha. O robot ao detetar a linha, roda
90º para a esquerda e de seguida, efetua uma curva em arco para contornar o objeto
detetado. Também roda o motor do sensor ultrassónico 45º para a direita para que
o mesmo se mantenha perfilado com o objeto detetado anteriormente enquanto se
movimenta até encontrar de novo a linha.
Durante o movimento, caso o sensor detete algum objeto a menos do valor “23” de
distância volta a desviar-se um pouco mais para a esquerda mantendo a rota de arco
até encontrar de novo a linha. Encontra de novo a linha quando o valor do sensor de
luz for inferior a 200 neste caso (um valor perto do central da linha). Nessa altura
termina este ciclo.

Depois de encontrar a linha, o robot para o movimento que estava a fazer. Enquanto
o valor da leitura do sensor de luz não for bastante alto (neste caso maior do que
461), ele vai rodar muito lentamente para a esquerda até o encontrar. Nessa altura
estará mais ou menos paralelo à linha preta, para poder prosseguir de novo o ciclo
de seguir a linha.
No final reiniciam-se os valores das variáveis temporárias do PID para que o robot
arranque mais suavemente ao iniciar de novo o seguimento da linha.

3.3 Imagens do Robot NXT
Figura 9 - Fotografia do robot utilizado.
Figura 10 - Imagem em perspetiva do robot utilizado.
Nas figuras 9 e 10 verificamos o robot utilizado neste trabalho. É possível verificar
que retirámos as borrachas das rodas traseiras para evitar algum atrito nas curvas e
assim minimizar os despistes. Desta forma o robot ficou mais estável a realizar o
percurso e este método foi adotado por toda a turma.

Figura 11 - Imagem do robot seguindo a linha definida.
Na figura 11 mostra-se o robot a percorrer a linha numa das calibrações do mesmo.
Figura 12 - Imagem do robot a desviar-se do objeto.
Na figura 12 é possível verificar o robot a contornar um objeto que foi detetado no
seu percurso. Foi utilizado como objeto o apagador do quadro disponível na sala.
Elaborámos também dois vídeos que mostram o robot a efetuar uma volta completa
(link) e o robot a contornar um objeto (link).

4 Conclusões
Em suma, retiramos como conclusões deste trabalho, que após compreendermos o
funcionamento do robot LEGO e compreendermos a arquitetura do seu
funcionamento, tornou-se simples comunicar com ele. Conseguimos desta forma
atingir os objetivos propostos do trabalho.
Utilizando a ferramenta “RWTH Aachen MINDSTORMS NXT Toolbox” disponibilizada
para comunicar com este tipo de dispositivos utilizando a ferramenta Matlab é
simples e eficaz a utilização do Matlab para a comunicação com o robot e envio dos
comandos e cálculos previamente elaborados.
Conforme já explicámos no decorrer do presente relatório, iniciámos a abordagem a
este trabalho concebendo um código de seguir a linha de forma mais básica e
simples. O robot segue assim a linha comparando os seus valores, através do sensor
ótico e desta forma reage dentro do intervalo dos dois valores configurados como
máximo e como mínimo. Assim o robot percorre a linha em ziguezague onde acelera
a roda esquerda quando o valor é baixo (meio da linha) e desacelera quando o valor
lido é alto (fora da linha).
Com esta abordagem, reparámos que o robot se tornava muito instável em
conseguir efetuar toda a volta sem se despistar, mesmo depois de calibrado. Caso os
valores de velocidades fossem baixos, (na ordem de 1 minuto por volta)
conseguíamos que ficasse mais estável e este conseguia efetuar várias voltas sem se
despistar.
Nesta altura já nos tínhamos deparado que as condições de iluminação e o valor das
baterias do robot influenciavam em muito os valores previamente afinados.
Como a velocidade era um dos objetivos do trabalho, tentámos subir este valor e aí
verificámos que com este método não iriamos conseguir valores estáveis com
velocidade superiores.
Então decidimos implementar um PID para controlo dos motores servos, para que o
robot se tornasse mais estável a percorrer todo o percurso pré definido com

velocidades superiores. Verificámos a base deste código no site referenciado no link
7 na bibliografia, onde analisámos a forma de aplicar o PID aos motores do LEGO.
Foi evidente o aumento de estabilidade e velocidade com a implementação deste
método de controlo. A afinação foi por tentativa erro, com a sugestão de alguns
colegas e após alguns testes consecutivos, conseguimos chegar a valores de boa
estabilidade. O robot já efetuava várias voltas sem se despistar a uma boa
velocidade (entre 40/45segundos).
Apesar de notável o melhoramento na estabilidade, continuava bem visível o facto
de com a mudança de luminosidade e a variação do nível de bateria nos valores pré-
encontrados como estáveis, o robot mudar de comportamento muito facilmente
devido a estas circunstâncias. Isto é, após encontrarmos valores estáveis, caso por
exemplo ao outro dia ensaiássemos com os mesmos valores na mesma pista, mas ou
porque as baterias estavam recarregadas ou a luminosidade do dia não era a mesma,
já tínhamos de novo que mexer nos valores da velocidade, do offset e por vezes nos
valores de afinação do PID. Isto para encontrar de novo um equilíbrio, em que o
robot fosse outra vez capaz de efetuar todo o percurso sem despiste.
Após esta fase, passámos a realizar o código necessário para contornar um
obstáculo.
Primeiramente, a abordagem tomada foi a de quando o robot encontrava um
obstáculo no seu caminho, com menos do que uma distância pré definida no sensor
de ultrassons, este para, movimenta-se 90º para o interior da pista, roda o sensor de
ultrassons 45º no sentido oposto ao do movimento para que ao se movimentar o
sensor continue a acompanhar o obstáculo. Consequentemente, contorna o objeto a
uma velocidade constante previamente definida. A roda da direita roda a uma
velocidade ligeiramente inferior à da esquerda para que o robot faça uma trajetória
curvilínea, que contorna o objeto até encontrar de novo a linha preta.
A base deste código ao qual nos referenciámos, está referenciado no link 5 na
bibliografia.
Após implementarmos esta forma de atuar, melhorámos o código para que o robot
enquanto se movimenta a contornar o objeto, continua a medir a distância do

obstáculo. Caso este se aproxime em demasia de novo do robot, este volta a afastar-
se do objeto, continuando de seguida a efetuar a trajetória curvilínea que estava a
fazer anteriormente, até encontrar de novo a linha preta. Após encontrar a linha,
coloca-se paralelo à mesma e retoma ao ciclo de seguir a linha, iniciando assim o
robot de novo o movimento.
Como dificuldades encontradas, destacamos as já mencionadas, da dificuldade inicial
em compreendermos o funcionamento e a concepção da forma de comunicar com
robot e posteriormente, o facto de termos sempre que reajustar os valores pré-
calibrados cada vez que voltarmos a utilizar o robot, tanto por motivos de iluminação
do meio, como devido ao desgaste da bateria do robot.
O tempo das aulas não nos foi suficiente para concluir o trabalho em tempo de aula
e apesar dos professores estarem prontamente disponíveis, para testarmos, tivemos
que pedir uma autorização extraordinária para utilização da sala em tempo de férias.
Além disso, tínhamos somente 4 robots para 9 grupos de 2 alunos, o que
evidentemente, cria transtornos ao tentarmos ensaiar os dados programados na
realidade. Sabemos que este tipo de trabalhos, necessita de obrigatoriamente
efetuar o teste real na prática para que se consigam resultados.

Bibliografia
[1] Slides disponibilizados nas aulas pelo professor António Moreira docente da
disciplina de Automação e Robótica.
[2] LEGO Mindstorms NXT, wikipedia.org,
http://pt.wikipedia.org/wiki/LEGO_Mindstorms_NXT, <consultado a 05-01-
2013>
[3] LEGO MINDSTORMS NXT Support from MATLAB,
http://www.mathworks.com/academia/lego-mindstorms-nxt-
software/legomindstorms-matlab.html, <consultado a 05-01-2013>
[4] RWTH - Mindstorms NXT Toolbox, Functions - Alphabetical List,
http://www.mindstorms.rwth-
aachen.de/documents/downloads/doc/version-4.03/abc.html, <consultado
a 05-01-2013>
[5] RWTH - Mindstorms NXT Toolbox, http://www.mindstorms.rwth-
aachen.de/trac/wiki/FunctionsOverview, <consultado a 05-01-2013>
[6] Basic robotics with Lego NXT, http://web.cs.dal.ca/~tt/robotics/NXTmatlab,
<consultado a 05-01-2013>
[7] A PID Controller For Lego Mindstorms Robots, J. Sluka,
http://www.inpharmix.com/jps/PID_Controller_For_Lego_Mindstorms_Robot
s.html, <consultado a 05-01-2013>

Implementação de um robot móvel

Mais conteúdo relacionado

Destaque

Semelhante a Implementação de um robot móvel

Mais de pjclima

Implementação de um robot móvel