Destroyer – Robô mini sumo por Daniel Barradas

Out 5, 2010

Os robôs mini sumo estão cada vez mais popularizados nas comunidades robótica por todo o mundo. Hoje apresento-vos uma criação de Daniel Barradas mais conhecido por iCar.

O Destroyer é um robô mini sumo, o seu cérebro é um ATmega328 com o bootloader do Arduino. Utiliza sensores infra-vermelhos para detectar os oponentes e phototransistors para detectar as extremidades do ringue de combate.

“Mini-sumo é uma competição entre robôs baseado em wrestling japonês;
Sumo em japonês significa wrestling;
Dois oponentes (robôs) enfrentam-se num anel chamado uma dohyo;
O objectivo é empurrar o robô oponente para fora do ringue;
O robô que permanecer no anel ganha a ronda.”

Esta categoria de sumo é apenas para robôs com um máximo de 10cm de largura por 10 de comprimento e 500 gramas de massa!

Alguns combates de sumo robótico:

Fotografias do Destroyer:

O sketch do código para o Arduino foi disponibilizado pelo autor:

// **************************************************************
// Destroyer - Mini Sumo Robot
//
// By Daniel Barradas (iCAR)
//
// 29/03/10 - Ver. 1.2
// **************************************************************
 
#include <EEPROM.h> // Libraria EEprom interna
 
// Digital Pins
#define LeftMotorDir1Pin 2 // Front
#define LeftMotorDir2Pin 3 // Back
#define CalibSwitchPin 4 
#define LeftMotorSpeedPin 5 // Pwm
#define RightMotorSpeedPin 6 // Pwm
#define RightMotorDir1Pin 7 // Front
#define RightMotorDir2Pin 8 // Back
// 9,10,11 estão livres
#define GrnLedPin 12
#define RedLedPin 13
 
// Analog Pins
#define IrLineFrontPin 0
#define IrLineRearPin 5
#define IrFrontPin 2
#define IrLeftPin 3
#define IrRightPin 4
#define IrRearPin 1
 
// Calibration Switch
int CalibSwitchVal = 0;
 
// Ir Sensor SHARP (Analog Input)
//int MinIrFrontValue = 500; // Muito perto (Calibragem sensores)
//int MedIrFrontValue = 250; // Perto (Calibragem sensores)
int MaxIrFrontValue = 100; // longe (Calibragem sensores)
int IrFrontVal = 0;
int IrFrontDetect = 0;
int IrFrontTolerance = 70;
int IrFrontTolMin = 0;
int IrFrontTolMax = 0;
 
// Ir Left Sensor (Analog Input)
int MaxIrLeftValue = 120; // longe (Calibragem sensores)
int IrLeftVal = 0;
int IrLeftDetect = 0;
int IrLeftTolerance = 20;
int IrLeftTolMin = 0;
//int IrLeftTolMax = 0;
 
// Ir Right Sensor (Analog Input)
int MaxIrRightValue = 1000; // longe (Calibragem sensores)
int IrRightVal = 0;
int IrRightDetect = 0;
int IrRightTolerance = 20;
int IrRightTolMin = 0;
//int IrRightTolMax = 0;
 
// Ir Rear Sensor (Analog Input)
int MaxIrRearValue = 500; // longe (Calibragem sensores)
int IrRearVal = 0;
int IrRearDetect = 0;
int IrRearTolerance = 500;
int IrRearTolMin = 0;
//int IrRearTolMax = 0;
 
// Ir Front Line Detect
int LineFrontVal = 0;
int LineFrontBlack = 800; // (Calibragem sensores)
int LineFTolerance = 5;
int LineFTolMin = 0;
int LineFTolMax = 0;
 
// Ir Rear Line Detect
int LineRearVal = 0;
int LineRearBlack = 800; // (Calibragem sensores)
int LineRTolerance = 5;
int LineRTolMin = 0;
int LineRTolMax = 0;
 
int BeginTime = 3500; // Tempo em Segundos iniciais conforme as regras (tenho que ajustar tem mais de 5 segundos)
int Debug = 0;
 
int Turn=0;
 
int MaxSpeed = 200;
int MinSpeed = 127;
 
//  Motors
int motor_left[] = {2, 3};
int motor_right[] = {7, 8};
int motor_PwrLeftPin = 5;
int motor_PwrRightPin = 6;
int MotorStatus;
int MotorStatusOld=0;
 
#define Motor_MaxSpeed 255
#define Motor_MedSpeed 150 // não estou a usar
#define Motor_MinSpeed 127 // não estou a usar
 
int Motor_leftSpeed = Motor_MaxSpeed;
int Motor_rightSpeed = Motor_MaxSpeed;
 
// ****************************************************************************************************
//
// Template: EEPROM_writeAnything - Escreve qualquer coisa na Emprom
// Retorno: int
//
// ****************************************************************************************************
template <class T> int EEPROM_writeAnything(int ee, const T& value)
{
    const byte* p = (const byte*)(const void*)&value;
    int i;
    for (i = 0; i < sizeof(value); i++)
	  EEPROM.write(ee++, *p++);
    return i;
}
// ****************************************************************************************************
//
// Template: EEPROM_readAnything - LÃª qualquer coisa da Emprom
// Retorno: int
//
// ****************************************************************************************************
template <class T> int EEPROM_readAnything(int ee, T& value)
{
    byte* p = (byte*)(void*)&value;
    int i;
    for (i = 0; i < sizeof(value); i++)
	  *p++ = EEPROM.read(ee++);
    return i;
}
 
// ****************************************************************************************************
//
// Estrutura: configuration - Estrutura da configuraÃ§Ã£o gravada na Emprom
// Retorno: Varios
//
// ****************************************************************************************************
struct config_t
{
  int FrontLine;
  int RearLine;
  int MaxIrFront;
  int MaxIrLeft;
  int MaxIrRight;
  int MaxIrRear;
} configuration;
 
void setup() { 
  pinMode(LeftMotorDir1Pin, OUTPUT); // Front
  pinMode(LeftMotorDir2Pin, OUTPUT); // Back
  pinMode(CalibSwitchPin,  INPUT); 
  digitalWrite(CalibSwitchPin, HIGH); // Turn PullUp on
  pinMode(LeftMotorSpeedPin, OUTPUT); // Pwm
  pinMode(RightMotorSpeedPin, OUTPUT);// Pwm
  pinMode(RightMotorDir1Pin, OUTPUT); // Front
  pinMode(RightMotorDir2Pin, OUTPUT); // Back
  pinMode(GrnLedPin, OUTPUT);
  pinMode(RedLedPin, OUTPUT);
  delay(50);
  Serial.begin(9600);  
 
  LoadConfig();
 
  CalibSwitchVal = digitalRead(CalibSwitchPin); // Get Calibratrion Jumper/Switch 
 
  if (CalibSwitchVal==HIGH){ // Ponho o robot em cima da linha para calibrar
    TurnLed(0,GrnLedPin);
    if (Debug==1){Serial.println("Calibrando Sensores");}  
    BlinkLed(RedLedPin, 5, 1000);
 
    LineFrontBlack = analogRead(IrLineFrontPin); // Front Lint Sensor
    BlinkLed(RedLedPin, 1, 500);
 
    LineRearBlack = analogRead(IrLineRearPin); // Rear Line Sensor
    BlinkLed(RedLedPin, 1, 500);
 
    MaxIrLeftValue = analogRead(IrLeftPin);
    BlinkLed(RedLedPin, 1, 500);
 
    MaxIrRightValue = analogRead(IrRightPin);
    BlinkLed(RedLedPin, 1, 500);
 
    MaxIrRearValue = analogRead(IrRearPin); 
    BlinkLed(RedLedPin, 1, 500);
 
    MaxIrFrontValue = analogRead(IrFrontPin);
    BlinkLed(RedLedPin, 1, 500);
 
    SaveConfig();
    delay(500);
    TurnLed(0,RedLedPin);
    TurnLed(1,GrnLedPin);
  } else { // Inicio Normal
    TurnLed(0,RedLedPin);
    TurnLed(1,GrnLedPin); 
  }  
 
  motor_Speed(motor_PwrLeftPin,Motor_MaxSpeed);
  motor_Speed(motor_PwrRightPin,Motor_MaxSpeed);
 
  LineFTolMin = (LineFrontBlack - LineFTolerance);
  LineFTolMax = (LineFrontBlack + LineFTolerance);
 
  LineRTolMin = (LineRearBlack - LineRTolerance);
  LineRTolMax = (LineRearBlack + LineRTolerance);
 
  IrFrontTolMin = (MaxIrFrontValue - IrFrontTolerance);
  IrFrontTolMax = (MaxIrFrontValue + IrFrontTolerance);
 
  IrRearTolMin = (MaxIrRearValue - IrRearTolerance);
 
  IrLeftTolMin = (MaxIrLeftValue - IrLeftTolerance);
  //IrLeftTolMax = (MaxIrLeftValue + IrLeftTolerance);
 
  IrRightTolMin = (MaxIrRightValue - IrRightTolerance);
  //IrRightTolMax = (MaxIrRightValue + IrRightTolerance);    
 
  // Falta Sensor de trás
 
  GetSensores();
  delay(BeginTime); // Perfaz 5 Segundos iniciais conforme as regras
  TurnLed(0,GrnLedPin);
}
 
void loop() {
 
  GetSensores();
  TurnLed(0,RedLedPin);
  TurnLed(0,GrnLedPin);
 
  if (Debug==1){
    //Serial.println(IrRearVal);
    //Serial.print(MaxIrFrontValue);Serial.print(" "); Serial.print(IrFrontTolMax); Serial.print(" ");Serial.println(IrFrontVal);
    //Serial.print(MaxIrRightValue);Serial.print(" "); Serial.print(IrRightTolMax); Serial.print(" ");Serial.println(IrRightVal);
    //Serial.println("-------------------------------------------------------------");
    //Serial.print(MaxIrLeftValue);Serial.print(" "); Serial.print(IrLeftTolMax); Serial.print(" ");Serial.println(IrLeftVal);
    //Serial.println("-------------------------------------------------------------");
    //Serial.print(LineFrontBlack); Serial.print(" "); Serial.print(MaxIrLeftValue); Serial.print(" "); Serial.println(MaxIrRightValue);
    //Serial.print(LineFrontVal); Serial.print(" "); Serial.print(IrLeftVal); Serial.print(" "); Serial.println(IrRightVal);
    //delay(100);
  }
 
   if (Debug==0){drive_forward();}
   DetectLine(1);
   DetectLine(2);
 
   if (IrFrontVal > IrFrontTolMax){ // Detectou Objecto Frente
      TurnLed(1,GrnLedPin);
      IrFrontDetect = 1;
      if (Debug==0){
         if (DetectLine(1)==false){drive_forward();}
      } else {
        Serial.print("Objecto Frente: "); Serial.println(IrFrontVal); 
      }
   } else if (IrFrontVal <= IrFrontTolMax){  // Não Detectou Objecto
      IrFrontDetect = 0;
    }
 
    if (IrRearVal < IrRearTolMin){ // Detectou Objecto atras
      TurnLed(1,GrnLedPin);
      IrRearDetect = 1;
      if (Debug==0){
          if (DetectLine(2)==false){  drive_backward();}
      } else {
       Serial.print("Objecto atras: "); Serial.println(IrRearVal);
      }  
    } else { // Nao Detectou objecto atras
      IrRearDetect = 0;
    }  
 
    if (IrLeftVal < IrLeftTolMin){ //detectou Objectos
      if ((IrFrontDetect == 0) && (IrRearDetect==0)){
        TurnLed(1,GrnLedPin);
        if (Debug==0){
          DetectLine(1);
          DetectLine(2);
          turn_left();
          delay(1000);
        } else {
          Serial.print("Objecto Esquerda: ");Serial.println(IrLeftVal); 
        }
      }
    }
 
    if (IrRightVal < IrRightTolMin){ //  detectou Objectos
      if ((IrFrontDetect == 0) && (IrRearDetect==0)){
        TurnLed(1,GrnLedPin);
        if (Debug==0){
          DetectLine(1);
          DetectLine(2);
          turn_right();
          delay(1000);
        } else {
          Serial.print("Objecto Direita: ");Serial.println(IrRightVal);           
        }
      }  
    }
}
 
boolean DetectLine(int LineSensor){
  GetSensores();
  if (LineSensor==1){ // Front Sensor
    if ((LineFrontVal < LineFTolMin) || (LineFrontVal > LineFTolMax)){ // Não detectou linha
      return false;
    } else { // Detectou linha
      TurnLed(1,RedLedPin);
      if (Debug==0){
        drive_backward();
        //DetectLine(2); 
        delay(1500);
        turn_left();
        DetectLine(1);
        delay(1000);  
      } else {
        Serial.print("Linha Frente: ");Serial.println(LineFrontVal);  
      }
      return true;
    }
 
  } else if (LineSensor==2){ // Rear Sensor
    if ((LineRearVal < LineRTolMin) || (LineRearVal > LineRTolMax)){ // Não detectou linha
      return false;
    } else { // Detectou linha
      TurnLed(1,RedLedPin);
      if (Debug==0){
        drive_forward();
        //DetectLine(2); 
        delay(1500);
        turn_right();
        //DetectLine(1);
        DetectLine(2);
        delay(1000);  
      } else {
        Serial.print("Linha Tras: ");Serial.println(LineRearVal);
      }  
      return true;
    }
  }
}  
 
// ****************************************************************************************************
//
// Funcao: LoadConfig - Le da estrutura configuration
// Retorno: nada
//
// ****************************************************************************************************
static void LoadConfig(void){
  EEPROM_readAnything(1, configuration);
  delay(500); 
  LineFrontBlack = configuration.FrontLine;
  LineRearBlack = configuration.RearLine;
  MaxIrFrontValue = configuration.MaxIrFront;
  MaxIrLeftValue = configuration.MaxIrLeft;
  MaxIrRightValue = configuration.MaxIrRight;
  MaxIrRearValue = configuration.MaxIrRear;
}
 
// ****************************************************************************************************
//
// Funcao: SaveConfig - Grava na estrutura configuration
// Retorno: nada
//
// ****************************************************************************************************
static void SaveConfig(){
 configuration.FrontLine = LineFrontBlack;
 configuration.RearLine = LineRearBlack; 
 configuration.MaxIrFront = MaxIrFrontValue;
 configuration.MaxIrLeft = MaxIrLeftValue;
 configuration.MaxIrRight = MaxIrRightValue;
 configuration.MaxIrRear = MaxIrRearValue; 
 EEPROM_writeAnything(1, configuration);
}
 
// ****************************************************************************************************
//
// Funcao: GetSensores - Faz a leitura dos sensores
// Retorno: nada
//
// ****************************************************************************************************
void GetSensores(){
  CalibSwitchVal = digitalRead(CalibSwitchPin);
  LineFrontVal = analogRead(IrLineFrontPin); // Front Line Sensor
  LineRearVal = analogRead(IrLineRearPin); // Rear Line Sensor
  IrFrontVal = analogRead(IrFrontPin); // Front IR Sharp
  IrLeftVal = analogRead(IrLeftPin); // Left IR
  IrRightVal = analogRead(IrRightPin); // Right IR
  IrRearVal = analogRead(IrRearPin); // Rear IR  
  //delay(50);
}
 
static void TurnLed(int Turn, int LedPin){
  if (Turn==0){
    digitalWrite(LedPin, LOW);
//    ledVal = 0;
  } 
  else if (Turn==1){
    digitalWrite(LedPin, HIGH);
//    ledVal = 1;
  }
}
 
void motor_Speed(int motorPin, int motorSpeed){
  analogWrite(motorPin, motorSpeed);
}  
 
void motor_stop(){
  if ((MotorStatus != MotorStatusOld) || (MotorStatus != 1));
  {
    digitalWrite(motor_left[0], LOW);
    digitalWrite(motor_left[1], LOW);
    digitalWrite(motor_right[0], LOW);
    digitalWrite(motor_right[1], LOW);
    delay(25);
    MotorStatus = 1;
    MotorStatusOld = MotorStatus;
  }
}
 
void drive_forward(){
  if ((MotorStatus != MotorStatusOld) || (MotorStatus != 2)){
    digitalWrite(motor_left[0], HIGH);
    digitalWrite(motor_left[1], LOW);
    digitalWrite(motor_right[0], HIGH);
    digitalWrite(motor_right[1], LOW);
    MotorStatus = 2;
    MotorStatusOld = MotorStatus;
  }
}
 
void softLeft(){
  if ((MotorStatus != MotorStatusOld) || (MotorStatus != 2)){
    motor_Speed(motor_PwrLeftPin,Motor_MedSpeed-50);
    motor_Speed(motor_PwrRightPin,Motor_MaxSpeed);
    MotorStatus = 2;
    MotorStatusOld = MotorStatus;
  }  
}
 
void softRight(){
  if ((MotorStatus != MotorStatusOld) || (MotorStatus != 2)){
    motor_Speed(motor_PwrLeftPin,Motor_MaxSpeed);
    motor_Speed(motor_PwrRightPin,Motor_MedSpeed-50);
    MotorStatus = 2;
    MotorStatusOld = MotorStatus;
  }  
}
 
void drive_backward(){
  if ((MotorStatus != MotorStatusOld) || (MotorStatus != 3)){
    motor_Speed(motor_PwrLeftPin,Motor_MaxSpeed);
    motor_Speed(motor_PwrRightPin,Motor_MaxSpeed);
    digitalWrite(motor_left[0], LOW);
    digitalWrite(motor_left[1], HIGH);
    digitalWrite(motor_right[0], LOW);
    digitalWrite(motor_right[1], HIGH);
    MotorStatus = 3;
    MotorStatusOld = MotorStatus;
  }  
}
 
void turn_left(){
  if ((MotorStatus != MotorStatusOld) || (MotorStatus != 4)){  
    digitalWrite(motor_left[0], LOW);
    digitalWrite(motor_left[1], HIGH);
    digitalWrite(motor_right[0], HIGH);
    digitalWrite(motor_right[1], LOW);
    MotorStatus = 4;
    MotorStatusOld = MotorStatus;
  }  
}
 
void turn_right(){
  if ((MotorStatus != MotorStatusOld) || (MotorStatus != 5)){
    digitalWrite(motor_left[0], HIGH);
    digitalWrite(motor_left[1], LOW);
    digitalWrite(motor_right[0], LOW);
    digitalWrite(motor_right[1], HIGH);
    MotorStatus = 5;
    MotorStatusOld = MotorStatus;
  }  
}
 
 
void turn_lng_left(){
  if ((MotorStatus != MotorStatusOld) || (MotorStatus != 6)){
    digitalWrite(motor_left[0], LOW);
    digitalWrite(motor_left[1], LOW);
    digitalWrite(motor_right[0], HIGH);
    digitalWrite(motor_right[1], LOW);
    MotorStatus = 6;
    MotorStatusOld = MotorStatus;
  }  
}
 
void turn_lng_right(){
  if ((MotorStatus != MotorStatusOld) || (MotorStatus != 7)){
    digitalWrite(motor_left[0], HIGH);
    digitalWrite(motor_left[1], LOW);
    digitalWrite(motor_right[0], LOW);
    digitalWrite(motor_right[1], LOW);
    MotorStatus = 7;
    MotorStatusOld = MotorStatus;
  }  
}
 
static void TestMotors(){
  drive_forward();
  delay(2000);
  drive_backward();
  delay(2000);
  turn_left();
  delay(2000);
  turn_right();
  delay(2000);
  /*turn_lng_left();
  delay(2000);
  turn_lng_right();
  delay(2000);
  */
  motor_stop();
}
 
static void BlinkLed(byte targetPin, byte numBlinks, byte blinkRate) { // single pin
  for (byte i=0; i < numBlinks; i++) {
      digitalWrite(targetPin, HIGH);   // sets the LED on
      delay(blinkRate);                     // waits for blinkRate milliseconds
      digitalWrite(targetPin, LOW);    // sets the LED off
      delay(blinkRate);
  }
}
#

Obrigado ao Joni do blog LIXADO por ter sugerido um artigo sobre sumo Robótico.

Escrito por André Delgado

Fundador e administrador do Make Bits, desde cedo que se interessou por robótica e micro-controladores, principalmente pelo Arduino. Já escreveu 116 artigos no Make Bits sobre os mais variados temas da robótica.

77616 Comentários2010-10-05+12%3A13%3A15Andr%C3%A9+Delgadohttp%3A%2F%2Fmakebits.net%2F%3Fp%3D776

joni08 5 de Outubro de 2010 às 14:33

Obrigado, já que fui eu que sugeri

Vou divulgar isto

Responder
- André Delgado 5 de Outubro de 2010 às 14:34
  
  Estava agora a editar para colocar o código, pode dar jeito
  
  Responder
  - david 9 de Março de 2011 às 23:47
    
    Boas
    
    ja aproveitando este topico eu gostava d saber se voces s importariam d me ajudar a programar o meu robô
    
    Responder
    - André Delgado 10 de Março de 2011 às 17:00
      
      Claro, sempre que tenhas dúvidas contactas-nos.
      
      Responder
      - david 11 de Março de 2011 às 0:13
        
        onde pode ser o sitio mais apropriado para te contactar?
      - André Delgado 23 de Março de 2011 às 23:45
        
        É só adicionares no mensseger: msn@makebits.net
      - david 23 de Março de 2011 às 21:33
        
        olha podias ajudar m com um sensor que estou a utilizar o qtr-8rc, nao me estou a dar mt bem com ele
      - André Delgado 23 de Março de 2011 às 23:45
        
        Boas, apenas tens de utilizar como um sensor normal… Experimenta obter valores simples com um potenciomentro e uns leds
joni08 5 de Outubro de 2010 às 18:34

Quanto pode custar um bot destes?

Responder
- André Delgado 5 de Outubro de 2010 às 23:36
  
  10€ para a gearbox
  10€ para as lagartas
  7€ para o breaduino
  5€ para a alimentação
  10€ para diversos
  
  10+10+7+5+10=42 no máximo 50€
  
  Responder
  - Filipe 6 de Outubro de 2010 às 0:07
    
    Não te esqueças do preço dos sensores/electrónica.
    
    Responder
    - André Delgado 6 de Outubro de 2010 às 0:13
      
      A electrónica (não é muita) tá incluida nos diversos – 10€. O que me esqueci foi do sensor IR frontal que custa +/- 14€
      
      Responder
      - Filipe 6 de Outubro de 2010 às 18:47
        
        Certo.
        
        Só mais um reparo. Pode sempre poupar algum "reciclando" alguns componentes coisas antigas. Um exemplo é utilizar rodas que se podem encontrar em velhas impressoras, em vez das lagartas
        
        Cumprimentos
      - André Delgado 6 de Outubro de 2010 às 18:58
        
        também se pode poupar nos sensores ir, fazendo uns em casa basta um comandos de televisão e uns televisores velhos e temos uns sensores IR por 0€
Carlos Faisca 16 de Novembro de 2011 às 20:05

gostava de saber como comprar um arduino UNO e o preço +/- pf
Obrigado

Responder
- André Delgado 18 de Dezembro de 2011 às 21:02
  
  Tens uma guia com varias lojas aqui no Make Bits
  
  Responder