Robô Sumo Zumo Robot Arduino Projeto para Batalhas

O Robô Sumo Zumo Robot é um projeto desenvolvido com Arduino especialmente para batalhas, já que as competições de sumô entre robôs estão se difundindo cada vez mais entre a comunidade maker e estudantes, tornando-se uma competição muito interessante, principalmente em relação ao aprendizado proposto a cada desafio na montagem do robô.

Além de estimular o conhecimento por meio da busca e aperfeiçoamento dos códigos de programação, esse tipo de robô prioriza o comprometimento e o trabalho em equipe para desenvolver um projeto que tenha competência técnica para vencer as lutas.

Mas você conhece como funcionam as competições? E que tal também conhecer esse incrível robô sumo criado pela UsinaInfo e todo o seu diferencial? É o que vamos ver hoje nesse prático tutorial que vai lhe ensinar tudo o que precisa saber sobre regras de jogo e a estrutura ideal para iniciar nas batalhas.

Robô Sumo Zumo Robot Arduino para Batalhas

Como funciona a competição de robô sumô?

A competição de robô sumô funciona com controle manual ou autônomo, no primeiro caso os competidores controlam seus lutadores por meio de joystick, no segundo caso, a programação prévia deverá prever todas as etapas da luta essenciais, deixando que ele faça todas as movimentações e ataques sozinho.

Em geral, na categoria autônomo (sem controle remoto) o microcontrolador Arduino se faz presente, 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 ele tomar as decisões propostas através da programação.

Para iniciar a batalha dois robôs são colocados frente a frente na arena, que nada mais é do que o local onde os mesmos ficam durante a disputa, geralmente sendo uma chapa de madeira de cor branca com a borda de cor preta ou dependendo da competição, pode ser a madeira pintada de cor preta e a borda branca.

Competição de Robô Sumô

O objetivo da luta de robô sumô é que os oponentes se enfrentem por determinado período de tempo e aquele que conseguir tirar o outro pra fora da arena vence, ah, se o robô sair sozinho da arena terá sua chance perdida. Se o tempo da batalha acabar sem que nenhum tenha saído dos limites da pista, a decisão caberá aos jurados que vão considerar os pontos gerados pelos ataques duranta a batalha. Outro detalhe importante é que se o robô não funcionar ou parar de funcionar será aberta uma contagem de tempo para que se movimente, caso não consiga, será considerado derrotado.

Em geral, esse tipo de luta é divido em três rounds, permitindo que o jogador possa tentar novamente vencer nas próximas tentativas, aquele que vencer dois rounds será considerado o campeão daquela luta. Com um sistema de chaves, os vencedores de cada batalha vão se enfrentando, até que reste apenas dois para a luta final que definirá o verdadeiro campeão.

Qual a origem da competição de robô sumô?

A competição de robô sumo tem como inspiração a conhecida luta japonesa de sumô, uma antiga luta secular que ainda perdura com algumas atualizações, mas que tem com objetivo básico colocar dois lutadores frente a frente, onde aquele que tirar o oponente primeiro da arena ou tocar o solo com qualquer parte do corpo do adversário que não as solas dos pés no chão, vence. Geralmente é um único round.

A versão dessa luta com robôs data do ano 2000, no Japão, onde admiradores do esporte incorporaram pequenas máquinas controlados por por rádio controles em uma batalha similar, com algumas regras atualizadas a modalidade. Em geral, esses tipos de robô sumô são divididos em categorias de acordo com o peso que possuem.

O Robô Sumo Zumo Robot Arduino RS100

O Robô Sumo Zumo Robot Arduino RS100 é uma versão criada especialmente pela UsinaInfo para competições robóticas em escolas e universidades, contando com os principais conjuntos de módulos e sensores para realizar uma batalha com perfeição, desde que devidamente programado.

Ele conta com um conjunto com três sensores de linha infravermelho responsáveis pela detecção das bordas da arena, impedindo que o robô saia da pista de forma de forma voluntária, além disso, na parte frontal conta com um sensor ultrassônico que pode ser utilizado para detecção do oponente, permitindo a rápida aproximação com impacto, de forma a tirá-lo da pista.

Visão interna do Robô Sumo Zumo Robot Arduino RS100

Vale destacar que esse modelo apresenta uma rampa frontal que protege seus componentes internos, além de permitir que empurre com maior facilidade o adversário para fora da arena. Toda a estrutura principal é desenvolvida em MDF 3mm, contando com peças cortadas a laser com ótimo acabamento e perfeito encaixe dos conjunto, sendo alguns por engates e outros com parafusos.

O Robô Sumo Zumo Robot Arduino RS100 é vendido em dois formatos, uma versão completa que possui todas as peças para montagem, incluindo toda a parte elétrica e eletrônica com Arduino. A outra versão é dotada apenas do chassi principal, permitindo que cada aluno integre os sensores que desejar, bem como comprar apenas os componentes eletrônicos que já não possuir, reduzindo assim custos no projeto.

Abaixo vamos disponibilizar um código básico de programação que pode ser utilizado com base para aprimoramento em batalhas, nesse momento, o sensor ultrassônico não será utilizado, assim ele também não estará presente no esquema elétrico.

Materiais utilizados no Projeto Robô Sumô

Abaixo seguem todos produtos utilizados no desenvolvimento do projeto, os quais pode ser adquiridos de forma avulsa conforma listagem. Se você quiser, pode adquirir a versão do Robô Sumo Zumo Robot Arduino Completo, o qual já possui todas as peças necessárias para montagem.

• 01 x Kit Chassi MDF Robô Sumô;
• 01 x Placa Uno R3 + Cabo USB para Arduino;
• 01 x Driver Duplo Ponte H de motor DC ou Passo L9110s;
• 01 x Carregador de Bateria 18650 Duplo;
• 01 x Módulo Adaptador USB Macho para DIP;
• 01 x Barra de Pinos 1×40 Vias 14,5mm 90° Macho – Preto;
• 01 x Sensor Ultrassônico de Distância HC-SR04;
• 01 x Chave Push Button PBS-102 104 Vermelha NF com Fios;
• 01 x Esfera Deslizante Metálica para Carro Robô;
• 02 x Motor com Fios Soldados e Caixa de Redução 48:1 200RPM + Roda;
• 02 x Baterias 18650 Li-Ion Recarregável 3.7V;
• 02 x Parafusos Philips M3 x 16mm Metálicos;
• 03 x Módulos Sensores Reflexivos Infravermelhos TCRT5000;
• 04 x Jumpers Premium para Protoboard Macho-Macho 20cm;
• 04 x Parafusos Philips M3 x 25mm Metálicos;
• 05 x Parafusos Philips M3 x 6mm Metálicos;
• 11 x Parafusos Philips M3 x 10mm Metálicos;
• 17 x Porcas M3 x 2,4mm Metálicas;
• 23 x Jumpers Premium para Protoboard Fêmea-Fêmea 20cm.

Dentre as maiores dificuldades no desenvolvimento do projeto, podemos destacar a questão da alimentação, em um modelo anterior da Usinainfo, o carrinho contava com a alimentação de uma Bateria 9V para o Arduino e o conjunto de 4 pilhas AA para a alimentação dos motores.

A busca pela unificação da fonte de alimentação e consequente corrente suficiente para ambos os setores do projeto acabou nos levando às Baterias 18650, equipamentos de corrente elevada que com o auxilio de um Case Carregador Duplo consegue fornecer 5V de saída e ainda recarregar as baterias incluídas no projeto.

Como o Carregador disponibiliza uma saída USB para alimentação, é necessário incluirmos ao projeto um conector USB, que pode ser desde um Módulo DIP quanto um Cabo USB Macho com fios para instalação dos jumpers. Cada modelo pode ser utilizado de acordo com a disponibilidade, porém para o Módulo DIP, por exemplo, é imprescindível a soldagem dos fios junto aos terminais, enquanto que no cabo, os pinos podem simplesmente ser emendados e isolados.

Cabo de alimentação Robô Sumô

Acima, vemos o primeiro modelo indicado, modelo que utiliza um módulo USB com os jumpers soldados, lembrando que também é possível destacar um pino da barra para fixação para auxiliar. 10 jumpers serão utilizados, 5 em cada um dos extremos do módulo, corte uma ponta para a união (isolamento pode ser feito com tubo termo retrátil ou fita isolante).

Já no caso de estarmos utilizando o Cabo USB Macho, o procedimento é quase o mesmo, porém difere-se nos detalhes. Também serão utilizados 10 jumpers, 5 no fio positivo (vermelho) e 5 no fio negativo (preto) de alimentação, corte uma ponta do jumper e decape sua ponta para realizar a união (isolamento pode ser feito com tubo termo retrátil ou fita isolante).

OBS: Para esta ligação, desconsidere os outros dois fios do Cabo USB.

Lembramos que o Cabo USB pode ser maior que o necessário, porém basta alocá-lo junto à estrutura do carrinho da melhor maneira possível que não haverá problema, ou pode optar por remover um pedaço do mesmo, mas lembramos que este é um procedimento que deve ser realizado com muito cuidado, para não deixar pequeno de mais e inviabilizar o projeto.

Esquema de ligação

O esquema elétrico do Robô Sumô Arduino tem uma montagem relativamente complexa, sendo necessário cuidado para evitar a inversão de polaridade dos terminais de alimentação dos módulos, assim evitando a queima dos mesmos. Siga exatamente como na imagem, agora com atualização incluindo o sensor ultrassônico.

Esquema Elétrico de Teste do Robô Sumo Zumo Robot Arduino RS100 

A montagem dos jumpers no Arduino possuem uma peculiaridade que auxilia no contato e na instalação dos mesmos e que se não seguida podem trazer uma certa dificuldade ao processo de instalação. Junto ao kit completo e também presente na lista de compras para o Carrinho Sumo está a parra de pinos 90º para fixação no Arduino e conexão do Jumper.

Esquema Elétrico de Teste do Robô Sumo Zumo Robot Arduino RS100

Como vemos acima, os pinos devem ser removidos da barra de separação plástica, este processo pode ser feito de duas maneiras, a primeira dela é a apresentada na imagem acima, empurrando o pino para fora da barra com o auxílio de um alicate, por exemplo, e a outra é cortando a barra em volta do pino com o auxilio de um alicate de corte, mas cuidado para não danificar a parte metálica.

E a montagem final ficou assim:

Organização dos Componentes Robô Sumô

Lembrando que a montagem da versão 2.0 é ainda mais simplificada, uma vez que os motores já são encaminhados com os fios soldados, assim como o botão para acionamento do carrinho.

 

Código de Programação do Robô Sumô

O nosso código de demonstração proposto a seguir faz com que o robô ande em frente até encontrar uma faixa de cor preta, ao encontrar essa faixa ele irá dar ré e girar e recomeçar a verificação da faixa, impedindo que saia da arena.

Lembrando que caso o PWM aplicado ao motor seja muito alto, e/ou seja revertido o sentido de giro, haverá um pico de corrente no power bank fazendo o mesmo desarmar, pois  a corrente ira ultrapassar o limite do power bank, sendo assim o PWM máximo para o robô funcionar em perfeitas condições é o valor 200 sendo aplicado a função “analogWrite”.

O código de programação utilizado na demonstração é esse:

C#

/******************************************************************************************************* ------------------------------------ Autor : Gustavo R Stroschon ----------------------------------------- ------------------------------------ Date: 21/02/2020 ---------------------------------------------------- ------------------------------------ Função do programa: código utilizado para a demonstração do robô sumo ------------------------------------ Revisado por: Victor Eduardo Ferreira (RC0D3) ----------------------- ------------------------------------ Data: 23/08/2024 ---------------------------------------------------- ------------------------------------ Atualização: Adicionado sensor ultrassônico ------------------------- *******************************************************************************************************/ //Incluir biblioteca V 3.0.0 #include <Ultrasonic.h> Ultrasonic ultrasonic(8, 7); // Trigger e Echo void setup() { pinMode(11, INPUT); // Sensor de linha pinMode(12, INPUT); // Sensor de linha pinMode(13, INPUT); // Sensor de linha pinMode(2, INPUT_PULLUP); // Botão de Ligar pinMode(5, OUTPUT); // Ponte H B-IA pinMode(6, OUTPUT); // Ponte H B-IB pinMode(9, OUTPUT); // Ponte H A-IA pinMode(10, OUTPUT); // Ponte H A-IB pinMode(8, OUTPUT); // Trigger Sensor Ultrassônico pinMode(7, INPUT); // Echo Sensor Ultrassônico Serial.begin(9600); while (digitalRead(2) == 0) { delay(1); stop(); Serial.println("Aguardando ligar..."); } } void loop() { if (!digitalRead(12) || !digitalRead(13)) { // Verifica sensores de linha Serial.println("Linha detectada"); stop(); delay(1); re(); delay(300); stop(); delay(1); girar(); delay(600); stop(); } int centimetros = ultrasonic.read(CM); if (centimetros < 30) { Serial.println("Oponente detectado"); stop(); delay(1); atacar(); delay(300); stop(); } frente(); delay(1); } void re() { Serial.println("Re"); analogWrite(5, 0); analogWrite(6, 150); analogWrite(9, 0); analogWrite(10, 150); } void frente() { Serial.println("Frente"); analogWrite(5, 150); analogWrite(6, 0); analogWrite(9, 150); analogWrite(10, 0); } void girar() { Serial.println("Girando"); analogWrite(5, 0); analogWrite(6, 150); analogWrite(9, 150); analogWrite(10, 0); } void atacar() { Serial.println("Atacar"); analogWrite(5, 200); analogWrite(6, 0); analogWrite(9, 200); analogWrite(10, 0); } void stop() { Serial.println("Parado"); analogWrite(5, 0); analogWrite(6, 0); analogWrite(9, 0); analogWrite(10, 0); }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105

/******************************************************************************************************* ------------------------------------ Autor : Gustavo R Stroschon ----------------------------------------- ------------------------------------ Date: 21/02/2020 ---------------------------------------------------- ------------------------------------ Função do programa: código utilizado para a demonstração do robô sumo ------------------------------------ Revisado por: Victor Eduardo Ferreira (RC0D3) ----------------------- ------------------------------------ Data: 23/08/2024 ---------------------------------------------------- ------------------------------------ Atualização: Adicionado sensor ultrassônico ------------------------- *******************************************************************************************************/   //Incluir biblioteca V 3.0.0 #include <Ultrasonic.h>   Ultrasonic ultrasonic(8, 7);  // Trigger e Echo     void setup() {   pinMode(11, INPUT);  // Sensor de linha   pinMode(12, INPUT);  // Sensor de linha   pinMode(13, INPUT);  // Sensor de linha     pinMode(2, INPUT_PULLUP);  // Botão de Ligar     pinMode(5, OUTPUT);   // Ponte H B-IA   pinMode(6, OUTPUT);   // Ponte H B-IB   pinMode(9, OUTPUT);   // Ponte H A-IA   pinMode(10, OUTPUT);  // Ponte H A-IB     pinMode(8, OUTPUT);  // Trigger Sensor Ultrassônico   pinMode(7, INPUT);    // Echo Sensor Ultrassônico         Serial.begin(9600);     while (digitalRead(2) == 0) {     delay(1);     stop();     Serial.println("Aguardando ligar...");   } }   void loop() {     if (!digitalRead(12) || !digitalRead(13)) {  // Verifica sensores de linha     Serial.println("Linha detectada");     stop();     delay(1);     re();     delay(300);     stop();     delay(1);     girar();     delay(600);     stop();   }     int centimetros = ultrasonic.read(CM);     if (centimetros < 30) {     Serial.println("Oponente detectado");     stop();     delay(1);     atacar();     delay(300);     stop();   }     frente();   delay(1); } void re() {   Serial.println("Re");   analogWrite(5, 0);   analogWrite(6, 150);   analogWrite(9, 0);   analogWrite(10, 150); } void frente() {   Serial.println("Frente");   analogWrite(5, 150);   analogWrite(6, 0);   analogWrite(9, 150);   analogWrite(10, 0); } void girar() {   Serial.println("Girando");   analogWrite(5, 0);   analogWrite(6, 150);   analogWrite(9, 150);   analogWrite(10, 0); } void atacar() {   Serial.println("Atacar");   analogWrite(5, 200);   analogWrite(6, 0);   analogWrite(9, 200);   analogWrite(10, 0); } void stop() {   Serial.println("Parado");   analogWrite(5, 0);   analogWrite(6, 0);   analogWrite(9, 0);   analogWrite(10, 0); }

 

Demonstração

O vídeo com a demonstração abaixo mostra a execução do código proposto, fazendo o robô evitar sair da arena.

Conclusão

No artigo de hoje abordei sobre o nosso Robô Sumô Arduino, o qual é muito interessante tanto pelo aprendizado proposto quanto pela diversão nas competições, podemos verificar em detalhes o projeto, mostrando pontos que podem der copiados ou modicados durante a criação de cada estudante.

Vale mencionar que a forma como utilizamos foi apenas uma sugestão de uso, isso porque, devido ao fato de todas as peças estarem disponíveis para venda, cada um pode escolher o que melhor atenderá a cada projeto, podendo inclusive adicionar joysticks ou mesmo controlar via Bluetooth pelo smartphone.

O código proposto também pode ser utilizado como base para o desenvolvimento do seu robô, podendo ser alterado sensores, módulos, motores e outras peças, de acordo com as regras da sua competição.

Ficou na dúvida? Quer contar suas experiências? Conta pra gente nos comentários. Compartilhe com seus amigos. Até a próxima!