Implementação de um robot móvel

897 views

Published on

Trabalho para a UC de Automação e Robótica
Paulo Lima e Luis Pais
IPCA, 2013

Published in: Engineering
0 Comments
1 Like
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total views
897
On SlideShare
0
From Embeds
0
Number of Embeds
5
Actions
Shares
0
Downloads
0
Comments
0
Likes
1
Embeds 0
No embeds

No notes for slide

Implementação de um robot móvel

  1. 1. 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
  2. 2. 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.
  3. 3. Implementação de um Robot Móvel 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.
  4. 4. Implementação de um Robot Móvel Í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
  5. 5. Implementação de um Robot Móvel Í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
  6. 6. Implementação de um Robot Móvel 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
  7. 7. Implementação de um Robot Móvel 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.
  8. 8. Implementação de um Robot Móvel Luís Pais / Paulo Lima 2 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.
  9. 9. Implementação de um Robot Móvel Luís Pais / Paulo Lima 3 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).
  10. 10. Implementação de um Robot Móvel Luís Pais / Paulo Lima 4 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.
  11. 11. Implementação de um Robot Móvel Luís Pais / Paulo Lima 5 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).
  12. 12. Implementação de um Robot Móvel Luís Pais / Paulo Lima 6 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.
  13. 13. Implementação de um Robot Móvel Luís Pais / Paulo Lima 7 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.
  14. 14. Implementação de um Robot Móvel Luís Pais / Paulo Lima 8 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;
  15. 15. Implementação de um Robot Móvel Luís Pais / Paulo Lima 9 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; motorSensor.SmoothStart = true; % Faz com que o motor inicie com uma acelaracao suave 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.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 % 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()
  16. 16. Implementação de um Robot Móvel Luís Pais / Paulo Lima 10 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.
  17. 17. Implementação de um Robot Móvel Luís Pais / Paulo Lima 11 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.
  18. 18. Implementação de um Robot Móvel Luís Pais / Paulo Lima 12 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.
  19. 19. Implementação de um Robot Móvel Luís Pais / Paulo Lima 13 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.
  20. 20. Implementação de um Robot Móvel Luís Pais / Paulo Lima 14 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.
  21. 21. Implementação de um Robot Móvel Luís Pais / Paulo Lima 15 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).
  22. 22. Implementação de um Robot Móvel Luís Pais / Paulo Lima 16 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
  23. 23. Implementação de um Robot Móvel Luís Pais / Paulo Lima 17 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
  24. 24. Implementação de um Robot Móvel Luís Pais / Paulo Lima 18 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.
  25. 25. Implementação de um Robot Móvel Luís Pais / Paulo Lima 19 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>

×