Ardusumo: an Open Source Platform for Fighting Robots

By on February 18, 2013

 

This slideshow requires JavaScript.

The idea

Ardusumo is a universal platform to build robots on wheels that can move around avoiding obstacles using infrared sensors and follow routes marked with dark lines on a white background.

We have created Ardusumo to bring young students to the world of robotics: if suitably programmed, Ardusumo allows robots to perform various autonomous movements, it integrates sensors and actuators of various types with wheels and electric motors.

The platform is Arduino based but consists of a single molded frame that is both mechanical and electronic circuit. It has also various possible assembly, thanks to the modularity and versatility of the connections.

Immagine 026 x apertura

The electronic circuit of the Ardusumo robot is very simple: the core is an Arduino UNO board, interfaced with four sensors – three in front and one on the back- and two Sharp infrared radar. The optical sensors are pointed down and used to follow tracks marked on the ground and recognize when the robot is crossing a delimited border.

Each optical sensor contains a light emitting diode, pointing towards the ground and a detector for reflected light. In this way it can distinguish thanks to light intensity (more light is detected when a more reflective surface is illuminated) the track to follow. The three front sensors are aligned. The middle one follows a track and detect whether the robot it has gone away from it. In that case the microcontroller detects the movement and imparts commands to correct it. The rear sensor is designed to detect when the robot approaches the edge of the ring. In this case, the firmware sends a forward motion command to break the deadlock.

The two infrared radar are pointed forward and slightly tilted sideways. They are the eyes of the robot, used to perceive obstacles and walk around them.

Two LEDs, to illuminate the scene in front of the robot, are interfaced to the Arduino. There’s also a buzzer to give alerts and a dual engines controller used to operate the two geared motors for the traction wheels.
The wheels are placed on the same virtual axis and, by varying the rotation speed,  Arduino “steers” the robot.

In the front, a “ball-caster” support serves as the third wheel for balance. A second ball-caster is located on the opposite side and contributes further to balanceing .

With the same track you can print both: the PCB that hosts all the basic electronics (works as a actual phisical basis) and the four mechanical and electrical connection to the infrared sensors. This in case you decide to mount them.

The Electric Scheme

Ardusumo_Schema

Ardusumo electronic circuit is based on Arduino: are the connections needed for the contacts on the board are available on side pin-strip. Via D4, D5, D6, D7, D8, D9 and D10, Arduino manages the motors controllers. PWM is used to drive the two motors so they provide traction and rotation to the robot. The robot steers with the same principle used for tanks: by rotating wheels in opposite directions.

The controller is a TB6612FNG: it contains a double PWM bridge driver, controllable by means of a simple logic. Each of the drivers is composed of an output bridge formed by four complementary MOSFET protected by a diode.

Each section of the pilot is controlled with a PWM signal to be applied to PWMA and PWMB lines (respectively channel A and B). That signal that is duplicated identical between M1 and M2. The AIN1 and AIN2 set A bridge operating mode, while BIN1 BIN2 and do the same for the bridge B.

This logic is used to determine the direction of rotation of each motor as well as its arrest. Clockwise rotation (connecting the motor with the polarity indicated in the diagram) is obtained with AIN1 set to high and AIN2 set to low, viceversa motor turns counterclockwise.

Setting AIN1 and AIN2 to logic 1, the motor stops. In this case the two N-channel MOSFETs are in the ON state, short-circuiting the motor.

Of course, other channels follow the same logic.

Esploso1

But let’s proceed with the analysis of the circuit diagram. Arduino‘s RST and A4 lines both link to a different button: P2 calls for reset, while P1 is reserved for custom applications.

The digital D1 line, used as output, pilots the LEDs arranged frontally to the robot. D0 is used to activate the firmware configurable buzzer BZ1.

The analog input lines A1 and A0 interface Arduino with the two infrared distance meters which provide an analog signal. This signal is proportional to the distance measured between the sensor and the obstacles faced.

GP2D12

Immagine 021

The sensors used for the detection of objects in front of the robot are Sharp GP2D12. The presence of two sensors lets us identify both the distance and the (approximate) position of obstacles: just by crossing data coming from the two sensors.

The GP2D12 sensors must be connected to the S1 and S2 connectors, which are connected to A1 and A0 lines. Each connector carries the 5-volt power and the ground, necessary to feed the devices. The “line sensors” are connected to the A2, D2, D3 and D1 lines of Arduino: they catch the analog signals that the sensors provide; each CNY70 sensor, has a LED and a phototransistor pointed in the same direction.

In this way a near object would reflect the light produced by the emitter diode that is then intercepted from the phototransistor. This effect produces an increase in the reverse saturation current in collector junction of the phototransistor.
The closer is the object is, the greater the reflected light, but pay attention to the color of the object. If the surface is white the reflection is greater than that obtained if it’s black. Every CNY70 has the emitter diode polarized directly with a resistor (R8 for T1, R2 for T2, R4 for T3 and R6 for T4). The phototransistor, polarized with the 5 volts on the collector, has the emitter connected to the input line from Arduino and ends to the ground with a resistor.

In this way, on on the emitter of the phototransistor, we have a voltage that is directly proportional to the intensity of the reflected light.

Finally, let’s see the power supply section: it is based almost completely on the Arduino’s circuitry and has a battery pack made up of 6 penlight batteries NiMH batteries (arranged in series , to obtain a nominal voltage of 7.2 volts). The positive and negative wires should be connected to + PWR and – PWR contacts of the base board. For the power supply you can even use six common penlight batteries, in which case we will get 9 volts on the PWR.

After passing the deviator on SW1 and fuse that protects the battery from shorts, the voltage reaches the contact Vin of Arduino, the Vin of the auxiliary connector and the resistive divider formed by R11 and R12. All this brings then the reference potential to A3 contact of Arduino.

Arduino regulator obtains the 5 volts for the on-board logic, and gives the voltage required to operate the entire circuit from his 5V contact . Through A3, Arduino can read the supply voltage and draw conclusions on the basis of the firmware that you will upload.

BOM

[code]

R1: 47 kohm
R2: 390 ohm
R3: 47 kohm
R4: 390 ohm
R5: 47 kohm
R6: 390 ohm
R7: 47 kohm
R8: 390 ohm
R9: 100 ohm
R10: 270 ohm
R11: 47 kohm
R12: 47 kohm

C1: 100 nF 63 VL
C2: 100 nF 63 VL
C3: 470 µF 16 VL
C4: 470 µF 16 VL
C5: 470 µF 16 VL
C6: 470 µF 16 VL
C7: 1 µF 35 VL
C8: 1 µF 35 VL
C9: 100 µF 35 VL

T1: CNY70
T2: CNY70
T3: CNY70
T4: CNY70

P1: Microswitch
P2: Microswitch

BZ1: Buzzer

SW1: Switch

U1: Driver motors (TB6612FNG)

LD1: LED 5 mm red
LD2: LED 5 mm red

Varie:
– Fuse 1 A
– Battery holder 6xAA
– Ball Caster mod. PBCASTER12 (2 pz.)
– Motors mod. BCM601 (2 pz.)
– IR Sensor GP2D120 (2 pz.)
– Wheels 60 mm mod. RUOTABCM (2 pz.)

[/code]

Check the store to find all components.

 

The firmware
With this post we intended to propose a development platform for robotics that is fully open-source and very versatile, leaving to each one the possibility to customize the firmware.

You can download  the firmwares  and allow you create a fighter robot.

/*
Simple program to test Ardusumo.
By Boris Landoni
www.open-electronics.org

*/
//piedinatura
int STBY = 4;                //pin stby motors OUT              (STBY)
int vel_mot_s = 5;          //pin speed motor sx OUT       (PWMA)
int vel_mot_d = 10;          //pin speed motor dx   OUT       (PWMB)
int dir_A_mot_s = 6;         //pin A dir motor sx OUT   (AIN2)
int dir_B_mot_s = 7;         //pin B dir motor sx OUT   (AIN1)
int dir_A_mot_d = 8;         //pin A dir motor dx OUT     (BIN1)
int dir_B_mot_d = 9;         //pin B dir motor dx OUT     (BIN2)
int inputTeleL = A1;  //sensor sharp IR
int inputTeleR = A0;  //sensor sharp IR
int inputSirL = 13;  //ir left
int inputSirC = 3;  //ir center
int inputSirR = 2;  //ir right
int inputSirB = A2;  //ir back
int buzz = 12;
int intens = A3;
int light = 11;
int puls = A4;

//definizioni
int sir_stimL;
int sir_stimC;
int sir_stimR;
int sir_stimB;

int tele_stimL;
int tele_stimR;

int tens;

boolean play=0;
boolean FF=0;

void setup() {
  //preset
   Serial.begin(9600);            // initialize serial communication with computer

   pinMode(vel_mot_s,OUTPUT);
   pinMode(vel_mot_d,OUTPUT);
   pinMode(dir_A_mot_s,OUTPUT);
   pinMode(dir_B_mot_s,OUTPUT);
   pinMode(dir_A_mot_d,OUTPUT);
   pinMode(dir_B_mot_d,OUTPUT);
   pinMode(STBY,OUTPUT);

   pinMode(tele_stimL,INPUT);
   pinMode(tele_stimR,INPUT);
   pinMode(inputSirL,INPUT);
   pinMode(inputSirC,INPUT);   
   pinMode(inputSirR,INPUT);
   pinMode(inputSirB,INPUT);
   pinMode(puls,INPUT);
   digitalWrite (puls,HIGH);

   pinMode(buzz,OUTPUT);
   pinMode(light,OUTPUT);

   //motor off
   digitalWrite(dir_A_mot_s,LOW);
   digitalWrite(dir_B_mot_s,HIGH);
   digitalWrite(dir_A_mot_d,LOW);
   digitalWrite(dir_B_mot_d,HIGH);
   analogWrite(vel_mot_s,0);
   analogWrite(vel_mot_d,0);
   digitalWrite(STBY,LOW);

   delay(1000);
} 

void loop() {
  if (digitalRead(puls)==0){
    if (play==1){
      play=0;
      motorSet("XX",0);
      led();   
    }
    else
    {
      play=1;
      led();
    }
  }

  if (play==1){
    avoidsobstacles();
  }

}

Do you like this project? Do you want to make one? Check the store.

About Boris Landoni

Boris Landoni is the technical manager of Open-Electronics.org. Skilled in the GSM field, embraces the Open Source philosophy and its projects are available to the community.