O objetivo desse trabalho foi construir um dispositivo mecânico que fosse semelhante à um manipulador. Para isso utilizamos o kit LEGO, um Arduíno e uma Ponte H L298N e dois motores de 9V, além de uma bateria de com mesma tensão.

A Ponte H, foi utilizada para permitir que, após ligado na bateria, fosse possível inverter a polaridade dos motores e assim girá-los para os dois sentidos. Isso é feito ligando cada vez um dos lados de um motor como na figura.

Como os motores precisam de uma tensão de 9V e o Arduíno só aceita 5V, foi necessário um pequeno circuito para conectarmos todos os componentes. A seguir o esquemático da parte eletrônica:

O cabo preto liga o fio terra do Arduíno e da Ponte H na bateria. O vermelho, liga o VCC na bateria alimentando a Ponte, outro cabo vermelho liga a tensão da ponte no Arduíno alimentando-o. Quatro cabos deixam o Arduíno levando as informações para a Ponte H e depois para os motores. Seguindo a seguinte lógica:

O projeto mecânico começou pela escolha dos tipos juntas que o robô possuiria. Limitando o uso de dois motores apenas, o projeto foi limitado também a utilizar apenas duas juntas. Tendo em vista que o robô RP (uma junta de revolução seguida por uma junta prismática com movimento coplanar) poderia ser descrito facilmente com coordenadas polares, foi esta a decisão tomada pelos componentes do grupo.

Após definido o tipo de movimento e o consequente espaço de atuação do efetuador, foi feita a escolha da estrutura. Optamos por uma torre com a parte de cima livre para rotacionar sobre a de baixo, e contendo o motor superior, a bateria e o controlador (Arduíno e Ponte H), enquanto a parte de baixo somente conteria o motor inferior e sustentaria a estrutura.

Após a montagem primária da estrutura, alguns testes simples indicaram que os motores precisariam de caixas de redução para conseguirem gerar torques grandes o suficiente para movimentar a estrutura. Foi decidido que os dois motores teriam uma caixa de redução de 27:1 (três mecanismos de redução 3:1 em série).

A parte de cima ficou com o movimento de translação, que foi realizado utilizando a barra dentada para transferir o movimento de rotação da engrenagem de transmissão para o eixo. A barra dentada precisava suportar ainda o peso do efetuados final e da caneta. Por isso, foi adicionada uma segunda barra, usada de apoio pela primeira.

A parte de baixo ficou responsável pela rotação da parte superior da estrutura utilizando um eixo em parafuso para girar uma engrenagem e transferir a rotação de um eixo horizontal para um vertical. Essa conexão porém, não ficou perfeita. Na verdade, havia uma folga entre o eixo e a engrenagem que permitia que por um pequeno espaço de tempo, um dos dois girasse sem acionar o outro. Essa folga persistiu e uma das maiores dificuldades encontradas, visto que ela parecia impedir a perfeita sincronização dos dois movimentos.

Por fim, apoiamos os componentes eletrônicos (Arduíno e Ponte H) sobre a estrutura, fixos por peças de LEGO.

Inicialmente, dados os pontos P1 a P6 mapeados no plano cartesiano, geramos todas as equações das retas definidas pelo pares de pontos adjacentes: P1-P2, P2-P3, e assim por diante. Com todos os pontos e equações de retas no plano cartesiano em mãos, convertemos eles para o coordenadas polares.

Assim, esperávamos que com uma rotação de base com velocidade angular constante, poderíamos de tempos em tempos capturar o ângulo percorrido e usar as equações de cada reta (em coordenas polares) para obter os devidos raios de acordo com o ângulo.

De posse do ângulo obtido naquele intervalo de tempo, do raio e da translação (raio - raio anterior) calculados, deveríamos ser capazes de transladar a junta prismática a distância necessária para corrigir o posicionamento da caneta até a reta.

Para o cálculo da translação, foi obtido experimentalmente o deslocamento realizado pela junta prismática em 1s. Essa ideia se aplica a cada uma das 5 retas. São elas:

R1 - P1 a P2;
R2 - P2 a P3;
R3 - P3 a P4;
R4 - P4 a P5;
R5 - P5 a P6;

Abaixo um trecho do código para Arduíno Black Board:

//4.12 é o ângulo em radianos do P1
while(rad > 2.36){ //3.6 é o ângulo do P2
    motorB(1, 100);
    segundos = segundos + 0,5;
    rad = radAnterior - VelocAngular * segundos; //precisa do radAnterior, pois o sentido de rotação é inverso ao de contagem dos ângulos
    raio = 900 / (sin(rad) + 6 * cos(rad));
    dif = raio - raioAnterior; //dif é o qto a junta prismática tem que se mover
    delay(700);
    motorB(0, 0);
    if(dif < 0){
      atraso = ((int)(-1 * dif) * (int)(1000 / 13)); //o motorA desloca 13mm em 1000ms a 85%(pwm)
      motorA(1, 85);
    }
    else{
      atraso = ((int)dif * (int)(1000 / 13)); //o motorA desloca 13mm em 1000ms a 85%(pwm)
      motorA(2, 85);
    }
    raioAnterior = raio;
    delay(atraso);
    motorA(0, 0);
  }

Vale salientar que as funções motorX(sentido, pwm) foram usadas para controlar os motores da base (junta de revolução) e da translação (junta prismática).

Como não obtivemos um total sucesso com a abordagem inicial, então, resolvemos fazer um código de força bruta. O código de força bruta faz com que o motor da base seja ligado por um tempo, realizando assim, uma rotação no sentido horário. Por um momento ele é desligado ligando o outro motor que é responsável por puxar ou empurrar a caneta, acarretando no movimento de translação por algum tempo. Esses tempos foram ajustados com um delay, sendo esses calibrados experimentalmente.

Abaixo um trecho do código alternativo para o Arduíno Black Board:

//Motor A (Base)  - Gira Sentido Horário
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
delay(2000);
 //Para o motor A
digitalWrite(IN1, HIGH);
digitalWrite(IN2, HIGH);
delay(500);

 //Motor B (Braço) - Estica
digitalWrite(IN3, HIGH);
digitalWrite(IN4, LOW);
delay(2000);
 //Para o motor B
digitalWrite(IN3, HIGH);
digitalWrite(IN4, HIGH);
delay(500);

 //Motor B (Braço) - Puxa
digitalWrite(IN3, LOW);
digitalWrite(IN4, HIGH);
delay(2000);
 //Para o motor B
digitalWrite(IN3, HIGH);
digitalWrite(IN4, HIGH);
delay(500);

Observando as estruturas montadas pelos outros grupos, percebemos que a nossa não ficou muito robusta, e permitiu que a barra entortasse pelo próprio peso, o que pode ter afetado o desempenho do sistema de translação.

Outro fator que ocasionou problema foi a questão da alimentação do circuito. A bateria de 9V utilizada acabou muito rápido impossibilitando o bom funcionamento do robô, e até mesmo atrapalhou na programação bruta.

http://blog.filipeflop.com/motores-e-servos/motor-dc-arduino-ponte-h-l298n.html