Cursos

Este trabalho prático consiste numa implementação conjunta de sensores e atuadores em malha aberta, de modo que de acordo com um determinado sinal analógico na entrada, uma decisão é tomada respeitando um algoritmo baseado nos pré-requisitos do trabalho. Além deste ponto, existem também tarefas relacionadas com a locomoção, que para o grupo foi desafio novo, levando em consideração que o trabalho anterior foi feito em uma base fixa.

• Introdução aos conceitos de controle em malha aberta para a robótica.
• Avaliação prática dos erros relacionados a montagem de um robô móvel.
• Familiarização com novas funções e algoritmos voltados para o controle em malha aberta para de um robô móvel utilizando um micro controlador Arduíno Mega.
• Introdução a utilização de funções digitais neste caso específico para o controle de um LED do tipo RGB.
• Familiarização com sensores do tipo analógico que não foram utilizados no trabalho prático anterior que consistiu apenas em atuadores em malha aberta.

• 1 LED RGB
• 3 Resistores
• Microcontrolador Arduino Mega
• 1 Sensor LDR
• Fios para ligação
• Interface para programação do Arduino.
• Peças de lego diversas para montagem da estrutura do robô
• Display de LCD

Esta parte consiste em três tarefas distintas, - Percorrer uma linha reta de 30 cm (IDA E VOLTA) - Percorrer um circuito equivalente a um triângulo retângulo isoceles de cateto igual a 30cm - Percorrer um circuito equivalente a um quadrado com lados iguais a 30cm

O robô deverá locomover-se por uma trajetória em linha reta. Em um determinado momento, o robô deve identificar a presença de um bloco à sua frente através de um sensor LDR. O robô deverá tomar uma decisão com base na cor do bloco identificado. Ações possíveis: * Bloco Aul → vire à direita 90 graus e ande para frente. * Bloco Amarelo → vire à esquerda 90 graus e ande para frente. * Bloco Vermelho → gire 180 graus e ande para frente. * Bloco Verde → pare e dê um giro de 360 graus.

Para isso foi utilizado um display com 6 botões

Após muito tempo pensando e tentando implementar diferentes posições para os motores, e formas de locomoção, especialmente para movimentos em que o robô deve fazer curvas, foi decidido que o robô usaria um motor para cada uma das rodas, que foram posicionadas em paralelo na parte de trás do robô. Inicialmente foi estudada a ideia de utilizar um motor para movimentar as duas rodas de forma que ambas girassem de forma igual em uma linha reta e utilizar um diferencial para que ele possa fazer curvas sem grandes problemas. A ideia foi descartada pela dificuldade de fazer o travamento de uma das rodas para que ele faça uma curva, além de o movimento não sair como desejado. Esta ideia foi levada até o ponto de montagem da estrutura, que posteriormente foi totalmente desmontada para a implementação da estrutura que será usada na apresentação. As rodas grandes foram de grande importância pos seu posicionamento é lateral, posicionamento devido a posição das caixas de redução que tinham o final virado para fora nas laterais do robô. As reduções foram feita na proporção de 81:1 utilizando engrenagens na parte interna do robô, com motores colocados cada um em uma extremidade da base principal. Na parte da frente foi montado o sensor LDR de forma que a luz externa seja bloqueada quando o mesmo se aproxima de um dos blocos, com o LED RGB logo acima e uma pequena inclinação de forma que a luz emitida seja melhor refletida no sensor LDR.

A implementação do código pode ser dividida em duas partes, a parte de reconhecimento e a parte de locomoção. Na parte de locomoção foram feitas funções para os principais movimentos que o robô deve fazer, como andar 30cm, virar 90° e etc. Uma das dificuldades na locomoção se deve a diferença que existe entre a rotação dos motores, dificuldade que foi contornada através de um sistema de proporção entre as rotações das rodas direita e esquerda. Na parte de reconhecimento foi implementada uma função que compara níveis de proporção entre os valores refletidos por cada um dos blocos, de forma que cada cor de bloco corresponde a uma forma de proporção predefinida no código com sua respectiva incerteza. As cores, vermelho, verde, azul e branco são lançadas em sequência no bloco que está a frente do robô e cada nível de luz refletida é lido e armazenado para a posterior comparação. De acordo com a cor identificada pelo código, as rodas giram de forma que execute a tarefa predefinida para cada uma das cores. Sobre a calibragem, foi implementada uma função que deve ler o nível de luz no ambiente, para ter um valor de referência e um nível de sombra do bloco (com o RGB desligado) para que tenhamos uma condição de parada para leitura da cor que está a sua frente. Quanto mais o código se tornava complexo e robustos foram notados pequenos bugs de sistema. Um bom exemplo é que a ausência de delay após as funções de chamada acarretam em um mal funcionamento do código.

motor1->setSpeed(0);
motor2->setSpeed(0);
delay(100); //necessário para a função a seguir ser integralmente implementada com sucesso
motor1->setSpeed(mot1);
motor1->run(BACKWARD);
motor2->setSpeed(mot2);
motor2->run(BACKWARD)

Podemos concluir que estes tipos de processo envolvem muitas variáveis que requerem bastante tempo, para que todos os possíveis erros relacionados sejam contornados utilizando uma combinação de estrutura física e código. Tomando como base o trabalho anterior podemos concluir que as variáveis analógicas que foram lidas são bastante sensíveis a variações externas como nível de luminosidade no local, proximidade com o bloco, entre outros fatores. Também podemos observar a diferença que há entre a rotação de motores que teoricamente seriam iguais e que acarretam erros posteriores, erros que podem ser potencializados pelas transmissões entre engrenagens que também estão sujeitas a muitas variações como o atrito ou um possível defeito. Um problema recorrente está relacionado com o nível de tensão que é fornecido pela bateria (associação de pilhas no caso) que a partir de certo ponto deixa de ser constante, fato que prejudica no ajuste fino, já que toda a programação é feita em malha aberta. De forma geral o resultado obtido foi satisfatório pois o robô conseguiu reconhecer todas as cores como esperado, fazendo também os movimentos pré-definidos de forma aceitável, fato que gerou contentamento no grupo que de forma conjunta trabalhou para sobrepor todos os problemas que surgiram.

Robô 1ª Versão. Rodas ainda com diferencial Robô em Versão final realizando os testes

TP1:Manipuladores ====

Neste primeiro trabalho prático nos foram dadas duas opções de atuação: O primeiro projeto que definia a criação de um robô manipulador que fosse capaz de seguir um caminho predefinido, o qual a região quadriculada é o local onde a base do robô se encontraria.

a2.pdf

Já no segundo projeto a ideia era utilizar um robô manipulador que escreveria UFMG em uma determinada seção da folha.

a4.pdf

Nos do grupo Robolfo escolhemos seguir o primeiro projeto(Movimento por pontos definidos).

Na montagem utilizamos o kit lego, dois motores DC, canetas, pilhas e o arduino MEGA 2560 além de dois Shields, um para os motores, outro que nos auxiliaria como um tela led. A equipe decidiu construir o robô com uma base fixa que iria rotacionar um braço com a caneta posicionada em sua extremidade em uma velocidade constante, seu braço iria ter uma esteira controlada por uma junta prismática. Como primeiro passo nós construímos uma caixa de redução para a base e construímos o braço, e após algumas mudanças conseguimos criar uma estrutura básica inicial do robô.

Na programação utilizamos uma biblioteca especifica do shield do arduino Adafruit_MotorShield.h e LiquidCrystal.h, nosso código na integra esta a baixo:

**esta versão não foi a usada no final

#include <LiquidCrystal.h>  
#include <Adafruit_MotorShield.h>
#include <Wire.h> 
#include "utility/Adafruit_MS_PWMServoDriver.h"

Adafruit_MotorShield AFMS = Adafruit_MotorShield();

Adafruit_DCMotor *motor1 = AFMS.getMotor(3);
Adafruit_DCMotor *motor2 = AFMS.getMotor(4);
//Adafruit_DCMotor *motor2 = AFMSbot.getMotor(3);

LiquidCrystal lcd(8, 9, 4, 5, 6, 7); 
int k=150;

void setup(){  
AFMS.begin();
lcd.begin(16, 2);  
lcd.setCursor(1,0);  
lcd.print("AlphaV.1");  
lcd.setCursor(0,1);  
lcd.print("Tecla: ");  
}  

void loop(){  
int botao;  
botao = analogRead (0);  //Leitura do valor da porta analógica A0

lcd.setCursor(6,1);  
if (botao < 100) {  
  lcd.print ("Start      ");
  
  //p1-p2
  
  motor1->setSpeed(250);
  motor1->run(BACKWARD);
  delay(6000);
   motor2->setSpeed(55);
  motor2->run(BACKWARD);
  delay(3000);
  motor2->setSpeed(0);
  delay(500);
   motor2->setSpeed(50);
  motor2->run(BACKWARD);
  delay(6750);
  motor1->setSpeed(0);
  motor2->setSpeed(0);
  delay(1000);

  //p2-p3
  motor1->setSpeed(250);
  motor1->run(BACKWARD);
  motor2->setSpeed(0);
  motor2->run(BACKWARD);
  delay(6050);
  motor2->setSpeed(50);
  
  delay(6800);
  motor1->setSpeed(0);
  motor2->setSpeed(0);
  delay(1000);

  //p3-p4
  motor1->setSpeed(250);
  motor1->run(BACKWARD);

  motor2->setSpeed(50);
  motor2->run(FORWARD);
  delay(6000);
  motor2->setSpeed(0);
  motor2->run(BACKWARD);
  delay(4000);
  motor2->setSpeed(60);
  delay(4050);
  motor1->setSpeed(0);
  delay(1000);
  
  /*
  //p4-p5
  motor1->setSpeed(250);
  motor1->run(FORWARD);
  delay(7050);
  motor1->setSpeed(0);
  delay(1000);
  
  //p5-p5/6
  motor1->setSpeed(250);
  motor1->run(BACKWARD);
  delay(7050);
  motor1->setSpeed(0);
  delay(1000);
  
  //p5/6-p6
  motor1->setSpeed(250);
  motor1->run(BACKWARD);
  delay(7050);
  motor1->setSpeed(0);
  delay(1000);

  //p6-p7
  motor1->setSpeed(250);
  motor1->run(BACKWARD);
  delay(7050);
  motor1->setSpeed(0);
  delay(1000);
  */

}  
else if (botao < 200) {  
  motor1->setSpeed(250);
  motor1->run(FORWARD);
}  
else if (botao < 400){  
  motor2->setSpeed(200);
  motor2->run(FORWARD);
  
}  
else if (botao < 600){  
  motor1->setSpeed(0);
  motor1->run(FORWARD);
  motor2->setSpeed(0);
  motor2->run(FORWARD);
}  
else if (botao < 800){
  motor1->setSpeed(200);
  motor1->run(BACKWARD);
  motor2->setSpeed(200);
  motor2->run(BACKWARD);
} 

  
 }

—-