Robótica

Como Montar e Programar um Robô Lutador de Sumô

Eletrogate 11 de janeiro de 2022

Introdução

No post de hoje, iremos te mostrar o passo a passo da montagem do nosso robô sumô utilizando a plataforma Arduino juntamente do kit de robótica 4WD em acrílico. Antes de começarmos, você sabe como funciona a competição de robô sumô?

Existem vários torneios de robótica nos quais existe a modalidade de robô sumô controlado e robô sumô autônomo. No primeiro caso, os competidores controlam seus robôs por meio de controles que podem ser joysticks, smartphones ou computadores. Já no segundo caso, a programação deverá prever e identificar o adversário e as bordas da arena, tendo, dessa forma, movimentações e ataques autônomos.

Competição de robô sumô.

Neste ponto, entra o microcontrolador Arduino, atuando como um cérebro eletrônico capaz de verificar todas as condições atuais do robô, através de sensores e módulos, fazendo com que ele tome as decisões propostas através da programação. No geral, a batalha inicia com dois robôs de lado ou de frente um para o outro. A arena geralmente é uma chapa de madeira ou metal de cor branca com a borda de cor preta ou vice-versa.

Robô finalizando o seu oponente.

A seguir, um vídeo de uma competição de sumô (Torneio Internacional de robôs -ITR 2019).

O vídeo a seguir é de um treino para modalidade sumô controlado a dois.


Materiais Necessários para o Projeto Robô Lutador de Sumô e Montagem do Robô

Agora que você já sabe o que é e como funciona um sumô de robôs, é hora de conhecer os componentes do nosso projeto de hoje:

Componentes do robô sumô.

Para fixação dos componentes no chassi de acrílico, você irá precisar de ferramentas como chave Phillips, alicate de corte ou bico e ferro de solda. Hora de colocar a mão na massa, ou melhor no chassi.

IMPORTANTE

Antes de iniciar, é necessário salientar que nossos kits são todos confeccionados em acrílico. Os comercializamos com uma película protetora de papel craft para evitar danos durante a fabricação e transporte. Vamos mostrar o processo de montagem do kit com a película apenas para facilitar a visualização do processo, mas, caso deseje o aspecto translúcido do acrílico em seu robô, basta retirar a película, conforme mostrado na imagem abaixo.

Removendo a película.

O nosso primeiro passo é a fixação dos espaçadores fêmea na parte inferior, que serão pontos de apoio para a parte superior.

Espaçadores fixados na parte inferior.

É importante que você os posicione ao longo das laterais, nos pontos mais frágeis. |Use uma chave Philips para apertar os parafusos, tenha cuidado ao apertar para não quebrar o acrílico.

Espaçadores fixados na parte inferior.

Parafusos fixados no suporte inferior.

Na sequencia, iremos soldar os fios nos 4 motores. Os fios que iremos utilizar são das cores vermelha e marrom, porém você poderá utilizar a que melhor achar. Lembre-se de soldar todos na mesma sequência, para facilitar na hora de ligar no motor shield.

Fios soldados nos motores DC.

Iremos passar uma fita isolantes nos fios para evitar que os mesmos quebrem os terminais dos motores na movimentação. Isto é opcional.

Fios isolados.

Para a fixação dos motores iremos posicionar os suportes que vão servir de apoio para os parafusos dos motores no chassi. Para isso, observe a imagem a seguir:

Suporte dos motores.

Agora, encaixe o motor entre os suportes e posicione os parafusos M3x30mm nos furos indicados, atravessando a carcaça do motor. Em seguida, coloque a porca. Você poderá utilizar um alicate de bico juntamente com uma chave Philips para apertar. Repita os passos nos outros suportes e motores.

Fixação do motor.

Motores fixados.

Para o encaixe das rodas, basta coloca-las na posição correta e empurrar.

Encaixe da roda.

Rodas encaixadas.

Para que o robô possa identificar as bordas da arena, iremos utilizar dois módulos sensor reflexivo TR5000, que irão ficar na parte de baixo do robô.

Módulos sensores reflexivos TR5000.

Para a sua fixação, iremos utilizar parafusos M3x20mm com porca e arruela, para evitar danificar o chassi ao apertar o parafuso.

Fixação do sensor reflexivo.

Um sensor vai ficar na frente e o outro na parte de trás do robô, você deverá escolher qual será a frente do seu robô.

Sensores fixados.

A parte inferior do robô deverá ficar conforme a imagem:

Sensores fixados.

Para a ligação dos sensores reflexivos, você deverá utilizar jumpers do tipo MxF. Aqui, as cores utilizadas são vermelha (VCC), preta (GND) e amarela (D0). Isto, para o sensor 1 (frente). Já para o sensor 2, as cores foram vermelha (VCC), preto (GND) e azul (D0).

Ligação do sensor 1.

Ligação do sensor 2.

Iremos partir para a parte superior do nosso robô, local no qual irá ficar a parte lógica: Arduino, motor shield e baterias. Para fixarmos o Arduino UNO, iremos marcar, com a ajuda de um lápis, onde iremos fixar os parafusos.

Marcação no chassi.

Após a marcação, você poderá furar utilizando uma furadeira e broca 4mm. A imagem a seguir mostrar como irá ficar as marcações.

Chassi marcado.

Para fixação da placa arduino, iremos utilizar 4 parafusos M3x16mm com porca e 8 arruelas lisas conforme a imagem:

Parafusos M3x20mm com porcas e arruelas lisas.

Os parafusos deverão ficar conforme a imagem a seguir:

Parafusos fixados na parte superior.

Pronto! Agora, é só encaixar o Arduino UNO.

Arduino fixado.

Já para a alimentação do nosso robô, iremos utilizar duas baterias 18650. Para isto, utilizaremos um suporte para duas baterias juntamente com dois parafusos e porcas, conforme a imagem a seguir:

Suporte para duas baterias 18650.

Após a fixação, o robô deverá ficar conforme a imagem abaixo:

Suporte das baterias fixadas.

Para a parte de controle dos motores, iremos utilizar o motor shield. Ele tem 2 chips L293D (datasheet) e um 74HC595, o que permite o controle de 4 motores DC, 2 servos ou 2 motores de passo e suporta motores com tensões de 4,5 à 16 VDC. Você deverá utilizar uma barra de pinos fêmea, que deverá ser cortada em três pedaços, com 6 furos cada, e um pedaço, com 4 furos, e soldar conforme as imagens a seguir.

Motor shield.

Barra de pinos cortada.

Local de solda dos pinos no motor shield.

Local da solda.

Esses barramentos são responsáveis pela alimentação dos sensores, bem como os pinos analógicos que iremos utilizar para sua leitura. Após a solda, o motor shield deverá ficar conforme a imagem:

Motor shield com os pinos soldado.

Pronto. Agora, é só encaixar o motor shield no Arduino UNO.

Motor shield acoplado no Arduino UNO.

Um interruptor é necessário para ligar e desligar o nosso robô. Iremos colocar um na parte de trás e iremos aproveitar um furo que tem próximo do suporte das baterias.

Interruptor.

Fixação do interruptor.

No interruptor, você deverá soldar, de um lado, o fio preto (negativo) que vem do suporte das baterias e, do outro lado, um outro fio preto que será ligado na alimentação do motor shield.

Fios soldado no interruptor.

Lembre-se de soldar dois pedaços de fios juntamente com os fios que vem do suporte. De preferencia, utilize as mesmas cores. Esses fios irão alimentar o Arduino UNO pelos pinos GND e Vin.

Fios de alimentação.

Agora, iremos colocar a parte superior do nosso robô. Existem espaços no suporte superior que iremos utilizar para passar os fios dos motores e dos sensores reflexivos. Na sequência, você deverá ligar a alimentação do motor shield: fio vermelho no +M, o preto no GND e os outros dois fios devem ser conectados nos pinos GND e Vin.

Bornes de alimentação.

Você deverá ligar os fios dos motores nos bornes do motor shied. Eles estão identificados por M1 (motor traseiro esquerdo), M2 (motor dianteiro esquerdo), M3 (dianteiro direito) e M4 (traseiro direito). Ligue conforme a imagem. Em seguida parafuse o suporte superior.

Ligações dos motores.

Agora, ligue os sensores reflexivos nos conectores que você soldou no motor shield. Obedeça a sequencia correta de ligação: os fios vermelhos (VCC) são nos conectores 5V, os fios pretos (GND) vão nos conectores GND, já o fio amarelo (D0 sensor 1) é ligado no conector A5 e o fio azul (D0 do sensor 2) é ligado no conector A4.

Ligação dos sensores reflexivos.

Ligação dos sensores reflexivos.

Estamos no final da montagem do nosso robô sumô, porém ainda falta o sensor responsável por identificar o adversário. Para isso, iremos utilizar o sensor ultrassônico HC-SR04 e quatro jumpers MxF.

Sensor ultrassônico HC-SR04.

Para fixação do sensor ultrassônico, utilizamos cola quente, conforme as imagens a seguir:

Fixação do sensor ultrassônico.

Fixação do sensor ultrassônico.

A ligação do sensor segue a sequência: fio vermelho (VCC) do ultrassônico é ligado no 5V do motor shield, o fio preto (GND) no GND, o fio verde ((ECHO) é ligado no conector A3 e, por ultimo, o fio laranja (TRIGGER) é ligado no conector A2. Pronto. Nosso robô está montado completamente. Você poderá adicionar nele uma rampa ou fazer algumas customizações e compartilhar conosco.

Robô finalizado.

Robô finalizado.


Esquema Elétrico

A seguir, descrevemos todo o esquema elétrico do robô feito no software fritzing. A criação do esquema elétrico irá facilitar na hora da montagem, bem como na manutenção do robô.

Esquema elétrico do robô.


Código do Robô Sumô

É hora de colocarmos o nosso robô para pensar. Para a programação, iremos utilizar duas bibliotecas: Arduino Motor Shield, que você poderá baixar neste link, e Ultrasonic, que pode ser baixada neste link.

A lógica do nosso robô é bastante simples. Ao ligar, ele irá girar para esquerda e verificar com o sensor ultrassônico se existe algo próximo dele. A distância de aferição será 20cm. Caso ele detecte algo, irá andar para frente até que o sensor reflexivo encontre a borda da arena. No nosso caso, estamos testando em uma arena de fundo branco e borda preta. Os sensores reflexivos, apesar de estarem ligados nas portas analógicas, estão sendo utilizados no modo digital, branco (0) e preto (1).

Estrutura de desenvolvimento.

Dentro da programação, existe uma função que poderá ser modificada para que o robô, ao invés de girar, ande na forma de um quadrado procurando o seu adversário.  A seguir, o código do robô sumô:

//Programa: Robô sumô
//Autor: Alexsandro
//Blog:  Eletrogate
//Versão: 1.0

//********************Inclusão das bibliotecas**************

#include <AFMotor.h>//Biblioteca do motor shield
#include <Ultrasonic.h>//Bibloteca do sensor ultrassônico

//********************Definição dos pinos********************

#define trigger A2
#define echo   A3
#define sensor1 A4
#define sensor2 A5

//********************Criação dos objetos********************

AF_DCMotor motor1(1);
AF_DCMotor motor2(2);
AF_DCMotor motor3(3);
AF_DCMotor motor4(4);
Ultrasonic ultrasonic(trigger, echo);

//********************Função de configuração******************

void setup() {
  //Configuração de velocidade dos motores
  motor1.setSpeed(255);//Velocidade vai de 0 a 255
  motor2.setSpeed(255);
  motor3.setSpeed(255);
  motor4.setSpeed(255);
  Serial.begin(9600);//Habilita a comunicação serial
  pinMode(sensor1, INPUT);//Configura o pino do sensor 1 como entrada
  pinMode(sensor2, INPUT);//Configura o pino do sensor 2 como entrada
}
//********************Função de principal********************

void loop() {
  //Cálculo e conversão da leitura do sensor ultrassônico
  long microsec = ultrasonic.timing();
  float distancia = ultrasonic.convert(microsec, Ultrasonic::CM);
  //Mostra as leitura dos sensores
  //Quando for ler remova o /* */
  /*
    Serial.print("A distancia: ");
    Serial.println(distancia);
    Serial.print("Sensor da frente: ");
    Serial.println(digitalRead(sensor1));
    Serial.print("Sensor da tras: ");
    Serial.println(digitalRead(sensor2));
    delay(1000);
  */
  //Verifica se tem alguma coisa na sua frente e se os sensor estão no branco
  if (distancia > 20 && digitalRead(sensor1) == 0 && digitalRead(sensor2) == 0) {
    Serial.println("procurando oponente");
    //Duas formas de procurar o oponente na arena
    procura();//Procura em forma de quadrado
    //esquerda();//Fica girando
  }
  //Se caso encontrar algo na sua frente
  if (distancia < 20 && distancia > 0 && digitalRead(sensor1) == 0 && digitalRead(sensor2) == 0) {
    while (digitalRead(sensor1) == 0) { //Prende na condição até o sensor encotrar a borda da arena
      Serial.println("achei o oponente");
      frente();//Movimenta para frente
    }
    parada();
    delay(1000);
    tras();
    delay(1000);
  }
  //Se caso encontre a borda e não o oponente
  if (digitalRead(sensor1) == 1 && digitalRead(sensor2) == 0) {
    Serial.println("Sensor da frente achou borda");
    tras();
    delay(500);
  }
  if (digitalRead(sensor1) == 0 && digitalRead(sensor2) == 1) {
    Serial.println("Sensor de tras achou borda");
    frente();
    delay(500);
  }
}
//********************Movimenta o robô para frente********************

void frente() {
  motor1.run(FORWARD); //Motor traseiro esquerdo
  motor2.run(FORWARD); //Motor dianteiro esquerdo
  motor3.run(FORWARD); //Motor dianteiro direito
  motor4.run(FORWARD); //Motor traseiro direito
}
//********************Movimenta o robô para trás********************

void tras() {
  motor1.run(BACKWARD); //Motor traseiro esquerdo
  motor2.run(BACKWARD); //Motor dianteiro esquerdo
  motor3.run(BACKWARD); //Motor dianteiro direito
  motor4.run(BACKWARD); //Motor traseiro direito
}
//********************Parada dos motores********************

void parada() {
  motor1.run(RELEASE); //Motor traseiro esquerdo
  motor2.run(RELEASE); //Motor dianteiro esquerdo
  motor3.run(RELEASE); //Motor dianteiro direito
  motor4.run(RELEASE); //Motor traseiro direito
}
//********************Movimenta o robô para esquerda********************

void esquerda() {
  motor1.run(FORWARD); //Motor traseiro esquerdo
  motor2.run(FORWARD); //Motor dianteiro esquerdo
  motor3.run(BACKWARD); //Motor dianteiro direito
  motor4.run(BACKWARD); //Motor traseiro direito
}
//********************Movimenta o robô em forma de quadrado********************

void procura() {
  frente();
  delay(300);
  esquerda();
  delay(300);
}

Resultado

É hora de vermos o resultado de todo o nosso trabalho. Vamos testar o nosso robô sumô nos dois modos da programação, girando e andando em forma de quadrado. São quatros vídeos de demonstração do robô funcionando.

Vídeo 1.

Vídeo 2.

Vídeo 3.

Vídeo 4.


Conclusão

Assim, concluímos o nosso robô sumô. Pudemos observar o quanto a plataforma Arduino é fantástica. Com ela, é possível elaborar projetos com cunho educacional e cientifico. Hoje, aplicamos junto desta plataforma dois tipos de sensores e um drive de potência para montagem de um robô de competição. Espero que este conteúdo tenha sido de grande ajuda e que você tenha conseguido finalizar e testar o seu robô. Deixe o seu comentário, sugestão e nos marque @eletrogate nas redes sociais com o seu robô pronto.

Conheça a Metodologia Eletrogate e ofereça aulas de robótica em sua escola!


Sobre o Autor


Alexsandro Ferreira
Instagram

Mestrando em Ciências da Computação pela Universidade Federal de Pernambuco, especialista e graduado em tecnologia em automação industrial, técnico em eletroeletrônica, professor de robótica desde de 2015, tutor das equipes de robótica Monster High, Athena e ELETRIDS. Amante da eletrônica e robótica.


Eletrogate

11 de janeiro de 2022

A Eletrogate é uma loja virtual de componentes eletrônicos do Brasil e possui diversos produtos relacionados à Arduino, Automação, Robótica e Eletrônica em geral.

Tenha a Metodologia Eletrogate dentro da sua Escola! Conheça nosso Programa de Robótica nas Escolas!

Eletrogate Robô

Cadastre-se e fique por
dentro de novidades!