Framework Arduino II: Aula 18 Motores Parte IV Robô

Recapitulando

    Na última aula vimos a utilização de uma ponte H controlando dois motores DC de uso genérico sem controle da velocidade. No entanto para a utilização em projetos de pequenos robôs é necessário comentar alguns detalhes e mostrar como se implementa um controle de velocidade sem solavancos. 

    Esses são os nossos objetivos de hoje.

Entendendo o básico

   Até agora estávamos mais preocupados em mostrar o funcionamento dos motores com o Arduino deixando de lado onde ele seria utilizado. No entanto, quando pensamos no sistema de tração de um robô precisamos nos preocupar com o torque.

    Torque é o esforço de um corpo para promover uma rotação em torno de um eixo. Quando você pega uma chave de fenda ou Philips e tenta desparafusar um parafuso essa força aplicada é o torque. Esse assunto é visto com mais detalhes nas disciplinas de Controle e Automação. Por enquanto nos interessa compreender a relação entre velocidade e torque.

    Quando pegamos uma bicicleta de marcha e olhamos para o seu conjunto de engrenagens notamos que na coroa próxima aos pedais, quanto maior é a engrenagem maior é o esforço que fazemos para pedalar. Já nos pinhões que são as engrenagens perto das rodas, quanto menor a engrenagem, maior é esforço.

    Pode parecer confuso, mas essa relação contrária acontece porque ambos os conjuntos de engrenagem alteram a relação entre o quanto pedalamos e o quanto as rodas giram. O giro representa o quanto a bicicleta se desloca. Quanto mais nos deslocamos em um mesmo intervalo de tempo, maior é a nossa velocidade.

    Quando pedalamos pouco e as rodas giram mais nosso esforço aumenta, mas quando pelamos muito e as rodas giram pouco, esse esforço é menor. Por isso engatamos marchas com a coroa de engrenagem menor e o pinhão de engrenagem maior nas subidas.

    O que estamos pretendendo com essas informações é mostrar para o estudante que quando um conjunto de engrenagens promove uma redução da velocidade, aumentamos o torque do motor. Por isso, para aplicações que exigem torque optamos por motores com caixa de redução.

Relação entre engrenagens, torque e velocidade

Motores com caixa de redução e eixo duplo

    Esses motores são recomendados para o uso em projetos de pequenos robôs porque oferecem um torque maior devido ao conjunto de engrenagens de redução em sacrifício da velocidade. O eixo duplo até permite utilizá-los com duas rodas por motor, mas na prática opta-se por um motor individual por cada roda devido a pouca potencia e do peso do conjunto.

    Pode-se, no entanto, utilizar esse eixo duplo para de um lado instalar uma roda e do outro um disco para encoder, caso seja necessário a medição da velocidade em RPM. Veremos em breve o que é um encoder e sua utilização.

Motor DC 3-6V com caixa de redução e eixo duplo

    Esses motores geralmente trabalham com tensões de 3-6V, com uma corrente de 150-200 mA, sua caixa de engrenagens promove uma redução de 1:48, ficando a velocidade em torno de 140 RPM com um torque de 0,35-0,80 Kgf/cm. Esses limites menores e maiores se referem ao uso de 3 ou 6V.

    Lembrando que são valores genéricos com base nas nossas pesquisas entre fornecedores, devendo o estudante SEMPRE consultar o Datasheet.

Kits robóticos

    Muitos fornecedores oferecem kits robóticos com esses motores sendo vendidos em pares,   juntamente com um chassi, duas rodas e outros componentes básicos para a plataforma de um robô. 

    Na maioria das vezes o chassi é projetado para três rodas, sendo a terceira de menor tamanho e giratória para auxiliar na movimentação, no entanto temos observado que duas rodas menores e giratórias posicionadas na frente e atrás do chassi oferecem melhor estabilidade ao projeto.

Exemplo de Kit comercializado com chassi de três rodas

    Olhando para esse Kit a primeira pergunta que os estudantes fazem é como faz ele ir para esquerda ou para a direita? Para isso podemos usar os mesmo princípio usado nos tratores e tanque de guerra que utilizam esteiras no lugar de rodas.

    Nesses veículos trava-se a esteira do lado para o qual queremos virar, enquanto o lado oposto continua rodando. No nosso caso, para virar a direita deixamos o motor direito com ZERO de rotação enquanto o esquerdo continua rodando na velocidade escolhida. Para o outro lado é o mesmo raciocínio.

    No entanto, dependendo do projeto, da forma do chassi, da distância entre as rodas, do peso, do centro de gravidade do carrinho, etc, pode ser necessário manter a roda do lado da curva rotacionando a uma velocidade menor ou rodando no sentido contrário. Caberá ao estudante fazer os devidos testes para esses ajustes.

Montagem

    Para ganhar tempo vou disponibilizar uma montagem pronta no TinkerCAD. Basta você clicar aqui entrando com a sua conta e pedindo para COPIAR E USAR.  Para essa primeira montagem de robô estou propondo um controle por botões e fios. Em uma postagem futura incorporaremos outro tipo de controle.

Montagem para uso em Robô controlado por botões e fios

    Diferente da aula anterior, agora estamos utilizando dois motores com caixa redutora e de eixos duplos ao invés do motor DC convencional. Um potenciômetro nos dará o ajuste da velocidade que será aplicada em ambos os motores. 

    O conjunto é controlado por sete botões em uma segunda protoboard, cujas funções são: Botão para trás, para frente, desacelera, freia, para esquerda, para a direita e reto. Isto se considerarmos sua disposição da esquerda para a direita na placa.

    Para evitar solavancos, tanto o botão para frente como o para trás dispões de um código que promove a aceleração, aumentando sua velocidade de maneira gradual, simulando que chamamos de Soft Starter no estudo de Controle e Automação. 

    O botão que desacelera usa o mesmo princípio, mas se preocupa em identificar se o robô estava avançando ou dando ré. Antes de frear ou mudar o sentido do movimento, isto é, dar marcha ré ou ir novamente para frente, recomenda-se usar o botão que desacelera. O botão freio encerra bruscamente o movimento.

    Os botões para a esquerda e para direita utilizam o que foi comentado para tratores. O botão para ir reto apenas para movimento com um ponto morto já comentado na aula anterior. A seguir os detalhes do código.

Sketch

    Para acessar o código dessa montagem clique no botão CÓDIGO no canto superior direito da tela do TinkerCAD e clique abaixo em MONITOR SERIAL para acompanhar as orientações impressão. O código é um pouco extenso, mas de fácil compreensão.

    De diferente da última aula, nos temos aqui as instruções para ir pra frente, para trás, para esquerda, etc, todas agrupadas em funções para facilitar o entendimento. Caso tenha dificuldade, clique aqui para relembrar a última aula.

    Como queríamos um controle de velocidade foi necessário utilizar os pinos PWM para controlar a ponte rolante, pois agora não queremos enviar apenas HIGH e LOW. Queremos enviar uma instrução respeitando a escala de 0 a 255 que o PWM permite.

    Para isso pegamos a leitura da entrada analógica utilizada pelo potenciômetro e mapeamos para a escala do PWM, armazenando isso na variável que chamamos de velocidade. Ao invés de dar comandos digitais para ponte H, enviamos esse valor de velocidade com analogWrite().

    O processo de aceleração e desaceleração que comentamos foi feito com um laço do tipo for, fazendo o sinal enviado por analogWrite() variar entre 0 e a velocidade desejada.

    Para verificar se o robô estava indo pra frente ou para trás adotamos uma variável booleana de controle chamada avanca que era alterada conforme o movimento escolhido. Essa variável é utilizada no processo de desaceleração.

1. const int input1=5;
2. const int input2=6;
3. const int input3=9;
4. const int input4=10;
5. const int pfrente=12;
6. const int ptras=13;
7. const int pdesacelera=11;
8. const int pfreio=8;
9. const int pesquerda=4;
10. const int pdireita=3;
11. const int pacerta=2;
12. const int potenciometro=14;
13. bool avanca=false;
14. int velocidade;
15. 
    
16. 
    
17. void setup() {
18.   pinMode(input1, OUTPUT);
19.   pinMode(input2, OUTPUT);
20.   pinMode(input3, OUTPUT);
21.   pinMode(input4, OUTPUT);
22.   pinMode(pfrente, INPUT);
23.   pinMode(ptras, INPUT);
24.   pinMode(pfreio, INPUT);
25.   pinMode(pesquerda, INPUT);
26.   pinMode(pdireita, INPUT);
27.   pinMode(pdesacelera,INPUT);
28.   pinMode(pacerta,INPUT);
29.   
30.   Serial.begin(9600);
31. }
32. 
    
33. void loop() {
34.   velocidade=map(analogRead(potenciometro),0,1023,0,255);
35.   delay(30);
36.   if (digitalRead(pfrente)==HIGH){
37.     Frente(velocidade);
38.     avanca=true;
39.   }
40.   if (digitalRead(ptras)==HIGH){
41.     Tras(velocidade);
42.     avanca=false;
43.   }
44.   if (digitalRead(pfreio)==HIGH){
45.     Freio();
46.   }
47.   if (digitalRead(pesquerda)==HIGH){
48.     Esquerda(velocidade);
49.   }
50.   if (digitalRead(pdireita)==HIGH){
51.     Direita(velocidade);
52.   }
53.   if (digitalRead(pacerta)==HIGH){
54.     Serial.println("reto");
55.     PontoM();
56.   }           
57.   if (digitalRead(pdesacelera)==HIGH){
58.     Desacelera(avanca,velocidade);
59.   }           
60. 
    
61. }
62. void Frente(int velocidade){
63.   PontoM();
64.   Serial.println("Para Frente");  
65.   analogWrite(input2, 0);  
66.   analogWrite(input4, 0);
67.   for (int i=0;i<=velocidade;i++){
68.     analogWrite(input1, i); 
69.     analogWrite(input3, i); 
70.     delay(10);
71.   }
72. }
73. 
    
74. void PontoM(){
75.   analogWrite(input1, 0); 
76.   analogWrite(input2, 0);  
77.   analogWrite(input3, 0); 
78.   analogWrite(input4, 0);
79. }
80. 
    
81. void Tras(int velocidade){
82.   PontoM();
83.   Serial.println("Para Tras");  
84.   analogWrite(input1, 0); 
85.   analogWrite(input3, 0); 
86.   for (int i=0;i<=velocidade;i++){
87.     analogWrite(input2, i);  
88.     analogWrite(input4, i);
89.     delay(10);
90.   }
91. }          
92. void Freio(){
93.   PontoM();
94.   Serial.println("Freio");  
95.   analogWrite(input1, velocidade); 
96.   analogWrite(input2, velocidade);  
97.   analogWrite(input3, velocidade); 
98.   analogWrite(input4, velocidade);
99. }
100. void Direita(int velocidade){
101.   Serial.println("Direita");
102.   analogWrite(input1, 0); 
103.   analogWrite(input2, 0);  
104.   analogWrite(input3, velocidade); 
105.   analogWrite(input4, 0);
106. }
107. 
     
108. void Esquerda(int velocidade){
109.   Serial.println("Esquerda");
110.   analogWrite(input1, velocidade); 
111.   analogWrite(input2, 0);  
112.   analogWrite(input3, 0); 
113.   analogWrite(input4, 0);
114. }
115. void Desacelera(bool avanca,int velocidade){
116.   Serial.println("Desacelera");
117.   if (avanca){
118.     Serial.println("para frente");
119.     analogWrite(input2, 0); 
120.     analogWrite(input4, 0); 
121.     for (int i=velocidade;i>=0;i--){
122.       analogWrite(input1, i);  
123.       analogWrite(input3, i);
124.       delay(10);
125.     }
126.   }
127.   else {
128.     Serial.println("para tras");
129.     analogWrite(input1, 0); 
130.     analogWrite(input3, 0); 
131.     for (int i=velocidade;i>=0;i--){
132.       analogWrite(input2, i);  
133.       analogWrite(input4, i);
134.       delay(10);
135.     }      
136.   
137.   }
138. }  

     Com relação ao mecanismo de direção, caso fosse um carro com mais velocidade, poderíamos utilizar outros artifícios como um eixo dianteiro cujo movimento poderia ser alterado por bobinas ou até mesmo usando um servo motor, mas isso é assunto pra outra postagem.

Próxima Aula                                                                                                                        Aula Anterior

Referências

BLOG ELETROGRATE. Guia Definitivo de uso da Ponte H L298N Disponível em <https://blog.eletrogate.com/guia-definitivo-de-uso-da-ponte-h-l298n/> Acesso em 17 nov 2024.

BLOG ELETROGRATE. Motor Shield L293D Driver Ponte H para Arduino Disponível em <https://blog.eletrogate.com/motor-shield-l293d-driver-ponte-h-para-arduino/> Acesso em 17 nov 2024.

VEX ROBOTICS COMPETITION Gear Ratios. Disponível em <https://cariwilliamzvex.weebly.com/gear-ratios.html> Acesso em 17 nov 2024.