Construindo um veículo autônomo de 4 motores com Arduino e Ponte H 293D

Fala moçada, tudo bem? No tutorial de hoje vamos construir um veículo autônomo de 4 motores com Arduino, Ponte H 293D, chassi 4WD, e um sensor de distância. A ponte H L203D será controlada pela nossa biblioteca que apresentamos em outro tutorial, o seu funcionamento será de forma automática com um servo motor e nele fixo um sensor ultrassônico HC-SR04, todo esse material você encontra em nossa loja online Arduino Ômega.

Conceito do projeto

A lógica do funcionamento será o robô andar por um ambiente e ao identificar um obstáculo ele para, olha pra esquerda e direita e vira para o lado que tenha maior distância do obstáculo, simples e prático.

Material utilizado

As ferramentas necessárias para montar seu projeto são:

Lembrando, tudo isso você encontra fácil na loja Arduino Ômega com entrega super rápida, só falar com a moçada no whats(clique aqui para entrar em contato via WhatsApp) que eles montam seu kit.

Montando o chassi

Na imagem acima você vê a forma tradicional de montar o carro de chassi duplo com 04 motores, monta-se a base inferior e os motores na face superior desta base, insere as colunas e logo em seguida a base superior, ficando os motores e eletrônicos entre as duas bases.

Neste formato, o carro fica rebaixado e as rodas passam da base superior, dependendo de sua aplicação, essa forma de montar não teria problemas, mas se o ambiente que o carro for andar seja acidentado, essa montagem iria atrapalhar um pouco e se caso deseje maior área livre em cima, as rodas passando atrapalha, como todo post aqui no Arduino Ômega sempre temos uma dica diferenciada pra te passar, neste não iria ser diferente 🙂

Na figura acima você pode observar claramente que o nosso carro está mais alto e o chassi superior está acima das rodas, podendo assim acomodar um projeto em cima sem se preocupar se vai bater nas rodas.

O primeiro passo na montagem do nosso projeto é soldar os fios nos polos dos motores, o motor não tem polaridade, ele funcionará se ligar o positivo (fio vermelho) e negativo (fio preto) de um jeito ou de outro, porém ele irá girar em sentido oposto, logo sugiro nomear o motor marcando-o em que eixo ele vai estar no carro, ai você testa ele com uma fonte e, na posição certa, quando girar no sentido que desloque o carro pra frente, solde o fio vermelho no polo que você testou o motor.

Faça o mesmo para os quatros motores, sempre conferindo o sentido de rotação, lembre-se que os motores estarão em lados opostos, logo a sua lógica de rotação para movimentar o carro pra frente é invertida, essa soldagem referenciada com o fio correto da cor é importante pois irá facilitar na lógica de programação do carro.

Quando concluir a soldagem, monte os motores no local conforme imagem acima, aproveite e instale logo o suporte da bateria com a chave on/off, qualquer dúvida consulte o circuito de ligação logo abaixo nesse mesmo artigo.

Suba os fios para a “parte que seria a interna”, entre os chassis, e lá instale o Arduino Uno com a shield L293D, conectando os motores nos bornes da shield.

O outro fio para subir é a alimentação que vem do borne da bateria, lembrando que o fio vermelho passa pela chave primeiro, conecte-os, fio vermelho e preto da bateria, nos pólos positivos e negativos da Shield nomeado como EXTRA POWER na imagem abaixo.

Para usar a alimentação externa, essa Extra Power, você precisa retirar o Jumper PWR, esse verde limão ao lado do borne Extra Power.

Adicione a base superior e pronto, essa primeira parte estará pronta, ligue o carro e veja se tudo está funcionando corretamente.

A ponte H L293D substitui essa tradicional L298 (que pode ser vista na imagem acima), neste caso, se você optar por usar a L298 terá 12 jumpers a mais de conexão, 4 de alimentação e usará 02 pontes desta para controlar 04 motores, logo, desperdício de dinheiro, bateria e muitas possibilidades de falha de conexão, logo, sugestão minha, vale muito mais a pena usar a L293D.

O último passo é instalar o servo motor com o sensor Ultrassônico HC-SR04, e concluir o projeto, optei por usar o servo na parte de baixo, porém com acesso a engrenagem na parte superior para fixar.

O Servo já tem um local fixo de conexão na shield, porém o ultrassônico não, e se você observar terá que soldar os fios Trig e Echo na shield, processo simples, sem erro, use a alimentação do servo motor para também alimentar o ultrassônico e os pinos de sinal solde na shield respeitando as portas no código e circuito logo em seguida.

Montagem do circuito

O nosso veículo autônomo de 4 motores tem um diagrama elétrico simples, no circuito abaixo, liguei o servo no pino 10, pois o componente do Fritzing não tem a conexão servo na Shields, mas se você olhar na parte superior esquerda acima do borne motor 1 e motor 2, tem 6 pinos, sendo para conexão de 02 servos motores, escolhemos o SERVO 1, justamente o que está conectado via shield no pino 10 do Arduino Uno.

Já o sensor Ultrassônico, basta soldar o pino Trig na porta 9 e o pino Echo na porta 2 do Arduino.

Desenvolvendo o código

Agora é a hora de desenvolver o código do veículo autônomo de 4 motores com Arduino, o uso da biblioteca foi explicado em nosso tutorial anterior, clique para conferir, se você ainda não conhece, dá um pulo lá que ensinamos a desenvolver essa biblioteca própria e explico o funcionamento geral dela. Clique aqui para baixar a biblioteca.O código fonte pode ser visto abaixo:

#include <L293D_PIXELS.h> //Inclue biblioteca
#include <Ultrasonic.h>
#define trig 9
#define echo 2
L293D_PIXELS  carro; //Declara instância
Ultrasonic ultra(trig, echo);

void setup() {}

void loop() {
  int distance = ultra.Ranging(CM);
  if (distance < 30) {
    paraCarro();
    if(distance < 5) carroRe();    
    olhaLados();   
  }else carroFrente();
}

void olhaLados(){
  carro.controleServo(180, SERVO_UM);
  int distanceDireita = ultra.Ranging(CM);
  carro.controleServo(0, SERVO_UM);
  int distanceEsquerda = ultra.Ranging(CM);
  carro.controleServo(90, SERVO_UM);
  if(distanceDireita >= distanceEsquerda) carroDireita();
  else carroEsquerda();
}

void paraCarro() {
  carro.giraMotor(MOTOR_UM, PARADO);
  carro.giraMotor(MOTOR_DOIS, PARADO);
  carro.giraMotor(MOTOR_TRES, PARADO);
  carro.giraMotor(MOTOR_QUATRO, PARADO);
  delay(1000);}

void carroEsquerda(){
  carro.giraMotor(MOTOR_UM, SENTIDO_INVERSO);
  carro.giraMotor(MOTOR_DOIS, SENTIDO_INVERSO);
  carro.giraMotor(MOTOR_TRES, SENTIDO_DIRETO);
  carro.giraMotor(MOTOR_QUATRO, SENTIDO_DIRETO);
  delay(1000);}

void carroDireita(){
  carro.giraMotor(MOTOR_UM, SENTIDO_DIRETO);
  carro.giraMotor(MOTOR_DOIS, SENTIDO_DIRETO);
  carro.giraMotor(MOTOR_TRES, SENTIDO_INVERSO);
  carro.giraMotor(MOTOR_QUATRO, SENTIDO_INVERSO);
  delay(1000);}

void carroFrente(){
  carro.giraMotor(MOTOR_UM, SENTIDO_DIRETO);
  carro.giraMotor(MOTOR_DOIS, SENTIDO_DIRETO);
  carro.giraMotor(MOTOR_TRES, SENTIDO_DIRETO);
  carro.giraMotor(MOTOR_QUATRO, SENTIDO_DIRETO);}

void carroRe(){
  carro.giraMotor(MOTOR_UM, SENTIDO_INVERSO);
  carro.giraMotor(MOTOR_DOIS, SENTIDO_INVERSO);
  carro.giraMotor(MOTOR_TRES, SENTIDO_INVERSO);
  carro.giraMotor(MOTOR_QUATRO, SENTIDO_INVERSO);
  delay(500);}

Na primeira parte do código invoco a biblioteca L293D_PIXELS.h que desenvolvemos e explicamos em outro artigo, e também a biblioteca Ultrassonic.h, observe que apesar de usar o Servo Motor, não há a necessidade de importar a biblioteca Servo.h pois ela já foi invocada dentro da biblioteca desenvolvida L293D_PIXELS.h, mais uma vez, se você ainda não leu o artigo que fala sobre essa biblioteca, dá um pulo lá e dar uma lida, assim você terá um melhor desempenho aqui.

Instanciamos um objeto que chamamos de carro a classe L293D_PIXELS.h e no void setup() não precisa fazer nada, isso mesmo, incrível a facilidade que essa biblioteca propõe, nada no setup.

O void loop() também ficou bem simples, na linha 11 ler o sensor ultrassônico, na linha 12 testa se a distância é menor que 30 se for verdadeiro chama a função que para o carro, quando o carro parar o programa testa se a distância é menor que 5 na linha 14, se for verdadeiro o programa chama a função que dá uma ré no carro, isso para evitar bater no momento da virada.

Em seguida, na linha 15, o programa chama a função responsável por movimentar o servo para olhar para esquerda e direita e decidir para qual lado virar.

Caso a distância seja maior que 30, ou seja a condição da linha 12 seja falsa, o programa chama a função para movimentar o carro pra frente.

Fácil, não é? Agora vamos entender as funções.

Na função olhaLados() , que pode ser vista no trecho de código abaixo, o objeto carro invoca a função controlaServo de nossa biblioteca desenvolvida onde nela se passa 02 parâmetros, o primeiro é o ângulo e o segundo qual servo movimentar.

Então o programa seguirá a seguinte ordem:

Linha 20 olha pra direita e armazena o valor da distancia

Linha 22 olha pra esquerda e armazena o valor da distância em outra variável

Linha 24 volta o servo pra posição central e testa quem tem maior distância, a maior distância irá chamar a função correspondente para o carro virar, carroEsquerda() ou carroDireita().

void olhaLados(){
  carro.controleServo(180, SERVO_UM);
  int distanceDireita = ultra.Ranging(CM);
  carro.controleServo(0, SERVO_UM);
  int distanceEsquerda = ultra.Ranging(CM);
  carro.controleServo(90, SERVO_UM);
  if(distanceDireita >= distanceEsquerda) carroDireita();
  else carroEsquerda();
}

A partir daqui é bem intuitivo e simples, a função paraCarro() quando chamada atribui para cada motor a instrução PARADO definido em nossa biblioteca através da função giraMotor() , já no caso de virar para esquerda inverte-se o sentido de rotação de uma lado do carro, lado esquerdo e mantém o SENTIDO_DIRETO para os motores do lado direito.

void paraCarro() {
  carro.giraMotor(MOTOR_UM, PARADO);
  carro.giraMotor(MOTOR_DOIS, PARADO);
  carro.giraMotor(MOTOR_TRES, PARADO);
  carro.giraMotor(MOTOR_QUATRO, PARADO);
  delay(1000);
}

void carroEsquerda(){
  carro.giraMotor(MOTOR_UM, SENTIDO_INVERSO);
  carro.giraMotor(MOTOR_DOIS, SENTIDO_INVERSO);
  carro.giraMotor(MOTOR_TRES, SENTIDO_DIRETO);
  carro.giraMotor(MOTOR_QUATRO, SENTIDO_DIRETO);
  delay(1000);
}

O mesmo se repete para virar para direita, porém tenha atenção que essa lógica pode ser invertida dependendo da referência que você montou a shield, se você montou ela em outra posição basta inverter a lógica.

void carroDireita(){
  carro.giraMotor(MOTOR_UM, SENTIDO_DIRETO);
  carro.giraMotor(MOTOR_DOIS, SENTIDO_DIRETO);
  carro.giraMotor(MOTOR_TRES, SENTIDO_INVERSO);
  carro.giraMotor(MOTOR_QUATRO, SENTIDO_INVERSO);
  delay(1000);
 }

void carroFrente(){
  carro.giraMotor(MOTOR_UM, SENTIDO_DIRETO);
  carro.giraMotor(MOTOR_DOIS, SENTIDO_DIRETO);
  carro.giraMotor(MOTOR_TRES, SENTIDO_DIRETO);
  carro.giraMotor(MOTOR_QUATRO, SENTIDO_DIRETO);
 }

void carroRe(){
  carro.giraMotor(MOTOR_UM, SENTIDO_INVERSO);
  carro.giraMotor(MOTOR_DOIS, SENTIDO_INVERSO);
  carro.giraMotor(MOTOR_TRES, SENTIDO_INVERSO);
  carro.giraMotor(MOTOR_QUATRO, SENTIDO_INVERSO);
  delay(500);
  }

Pronto pessoal, código finalizado!

Conclusão

No tutorial de hoje usamos um conceito avançado de programação que é usar uma biblioteca própria em um projeto real! Nós desenvolvemos a biblioteca no post anterior, e a usamos em veículo autônomo de 4 motores com Arduino, neste tutorial! Foi ensinado como controlar quatro motores com a Ponte H L293D, usamos conceitos de controle de servo motor, e medição de distância, e com este conceitos conseguimos fazer o nosso veículo se movimentar desviando dos obstáculos a frente!

O grande aprendizado deste tutorial é que quanto mais conceitos, quanto mais módulos, sensores, nós conhecermos mais possibilidades teremos em nossos projetos!

Eu acho que é isso pessoal, qualquer dúvida pode me contactar pelo Instagram @profsandromesquita ou comentar aqui mesmo que estaremos aqui para ajudar, até o próximo post.

Sobre Sandro Mesquita 12 artigos
Prof. Sandro Mesquita, Msc. Eng de Software, CREA - 44680 .

1 Trackback / Pingback

  1. Aprendendo a identificar cores com Arduino e o sensor TCS320 -

Deixe uma resposta

O seu endereço de email não será publicado.


*