Conductivity Test

In order to detect the presence of conductors,the simplest test is the Conductivity Test. Conductivity of a substance is defined as ‘the ability or power to conduct or transmit heat, electricity or sound’. Here what we use is the ability to transmit electricity. When an electrical potential difference is placed across a conductor, its movable charges flow, giving rise to electric current. We would be using this property of conductors to complete the circuit connections as shown below. The material being a conductor completes the circuit and the LED glows.If the material is an insulator, the circuit will not be completed and the LED would remain off thereby indicating presence of an insulator.

Work Done By- Pranav Ramkrishnan, Std.12th

Objective:

This is an extremely simplistic, yet interesting application using the i-Mach kit to make something that can do real and useful work. The basic aim of this task is to build and program an autonomous robot that can detect objects within its surrounding environment and having detected the object, the robot must push the object out of the arena. However the robot must at all times remain within the arena, just as a bull must remain within the bull fighting arena. Imagine if the bull left the ring, it would result in chaos!

This problem statement adapted in this task is one that has been used in several international robotic competitions and events at high school and college levels , however it has never been attempted with the i-Mach kit, hence giving us opportunity to explore the boundaries of this kit.

To make a robotic application, we shall be using metal cans, as objects and design an arena which is black and has a white boundary around it.

Description of the Robot:

The structure of this robot was made using the mechano parts provided in the i-Mach kit. It was important to design a framework which is both sturdy and compact. Before going into the explanation of the physical structure, here is a list of sensors used to make this particular version of the “Bull”:

· 3 Obstacle Sensor – used to detect the metal can (object), the arrangement of these sensors has been discussed below.

· 2 Line sensors – used to sense the edge of the arena (white) so that the robot does not go out of the arena.

Here is a picture of “Bull” and the design as been explained below:

Figure 1. “The Bull”

Explanation:

Obstacle Sensors:

Sensor2, Sensor3 and Sensor4 are all obstacle sensors, that are used to detect the presence of the object, in close proximity to the robot. In order to make sure that the robot is able to read an object from all angles, the sensors are placed, one facing forward – so that if an object(metal can) is in front, the robot will charge towards it and then push it out. Two more obstacle sensors were placed on the two sides of the robot (left and right) so that if the robot as no object in front of it, but one on either sides, it must be able to detect it, turn to the respective side and then charge forwards to push the can out of the arena.

Line Sensors:

Sensor6 and Sensor6 are line sensors.The placement of line sensors is fairly obvious. The sole purpose of the line sensors is to give a feedback (HIGH) when the sensor is over a white surface and a LOW feedback when the sensor is over a black surface. It is interesting to consider why only two line sensors were placed, one front and back and why no more line sensors were place on either sides of the robot. Well, the answer to this is that the robot will be only pushing the metal can from the front. So Sensor6 is the main line sensor that will be detecting the edge. Sensor5 is an extra sensor, which is used so that in case the robot reversing and moves towards the line, it detects the line so that the robot can move forward. So since the robot will not be moving sideways, there is no need to place anymore line sensors on the side, like we placed obstacle sensors on the side as well.

Now coming to the Physical design:

Figure 2:

In order to build a stable robot, one must keep the robot as low as possible, also since this has a specific function to push an object, the robot must have a grabbing mechanism. Shown in Figure 2, this particular robot can only hold a specific size of obstacle, although is the object is bigger then the robot could still push it forward (of course, provided the motors used can support the load!). While building this grabbing mechanism, one must also remember to protect the sensors from impact with the object. One can make the grabbing mechanism longer and wider, but if that is done, the robot is going to start leaning forward, and may not be as stable as before (centre of gravity will shift forward). Further, the robot will become a lot slower, and generally speaking bulls are fast animals!!

Figure 3: “The Bull” at work

Algorithm:

The algorithm logic used to program this robot is fairly easy to comprehend.

Points to keep in mind while reading this algorithm:

Ø Line sensor is ON over a white surface and OFF over a black surface

Ø Obstacle sensor is OFF when an object is in front of it and ON when there is no object in front of it.

So the algorithm logic is as follows:

1. Move forward.

2. If Sensor6 is ON, then go back, turn around and move forward (this is detecting a white line and then moving away from it)

3. While moving forward check if Sensor2 is OFF, if Sensor2 is OFF continue going forward, until line.

4. While moving forward check if Sensor3 is OFF, if Sensor3 is OFF, then stop and keep turning to the right until Sensor2 is OFF (this means the object is now in front of the robot). Then move forward with the metal can to the edge.

5. While moving forward check if Sensor4 is OFF, if Sensor4 is OFF, then stop and keep turning to the left until Sensor2 is OFF, then move forward.

6. If Sensor5 is ON, then move forward (white edge is behind the robot and it has to move forward).

PROGRAM:

BEGIN

{

FOREVER

{

IF(SENSOR6 IS ON) // Forward Line Sensor detecting a white edge.

{

RIGHTMOTOR(FORWARD,100); // Inspite of detecting the white edge the robot

continues forward for 250 milliseconds to ensure

LEFTMOTOR(FORWARD,100); // that the object has been completely pushed

out of the arena.

WAIT(250);

RIGHTMOTOR(0,0); // Stops for 500 milliseconds

LEFTMOTOR(0,0);

WAIT(500);

RIGHTMOTOR(BACKWARD,100); // then comes backward for 1 sec, to avoid

the line

LEFTMOTOR(BACKWARD,100);

WAIT(1000);

RIGHTMOTOR(FORWARD,100); // takes a differential right turn (turning on the

spot) for 1.5 seconds,

LEFTMOTOR(BACKWARD,100); // this is approximately 180 degree on full

batteries.

WAIT(1500);

}

IF(SENSOR6 IS OFF) // Case when the robot is in the arena, that is on a black

surface, the robot moves forward.

{

RIGHTMOTOR(FORWARD,100);

LEFTMOTOR(FORWARD,100);

IF(SENSOR2 IS OFF) // Conditions while moving forward

{

RIGHTMOTOR(FORWARD,100); // Case 1 – Object in front of the robot, the

robot continues forward, until the white

edge.

LEFTMOTOR(FORWARD,100);

}

IF(SENSOR4 IS OFF)

{ // Case 2 – Object on the left side.

RIGHTMOTOR(0,0);

LEFTMOTOR(0,0);

WAIT(500);

WHILE(SENSOR2 IS ON)

{

RIGHTMOTOR(FORWARD,100); // Turning differentially to the left while

Senso2 reads the object

LEFTMOTOR(BACKWARD,100);

}

RIGHTMOTOR(FORWARD,100); // Pushing the object out after turning.

LEFTMOTOR(FORWARD,100);

}

IF(SENSOR3 IS OFF)

{

RIGHTMOTOR(0,0); // Case 3 – Object on right side

LEFTMOTOR(0,0);

WAIT(500);

WHILE(SENSOR2 IS ON)

{

LEFTMOTOR(FORWARD,100); // Once again turning differentially until

Sensor2 reads the object

RIGHTMOTOR(BACKWARD,100);

}

RIGHTMOTOR(FORWARD,100); // Pushing the object out of the arena.

LEFTMOTOR(FORWARD,100);

}

}

IF(SENSOR5 IS ON) // Behind line sensor detects the white edge. The robot

moves forward to avoid edge. No pushing from the back.

{

RIGHTMOTOR(FORWARD,100);

LEFTMOTOR(FORWARD,100);

}

}

}

END

Here is the Video link to have a glimpse of what the bull in the ring is exactly upto:

http://www.youtube.com/watch?v=SSl5xa6xDNM

Further Development (Food for Thought):

Although this robot is successful in accomplishing its task, that is to push away the metal cans from the arena without leaving the arena, there are possibilities for development and enhancement:

Physical/ Structural:

1. One can think about making a lifting mechanism instead of a gripping mechanism, something like a crane or a forklift.

2. The Robot can be used as a arena cleaner if can be made faster and stronger, so that it can even clean bigger areas.

3. Design an arm such that the robot can lift objects of different dimensions.

Abilities:

1. One could program the robot to pick up an object, come to a particular spot and drop it.

2. Instead of picking up every single object from the arena, the robot can be programmed in such a way that it only selects a particular type of object.

3. This can be further expanded into thinking about sorting out random objects in an enclosed arena into sorted groups.

• Throw it into the dustbin!(or any other place u want to).
Building one would require a few extra parts which are not included in the
i-MACH kit. The list of such parts is given below-
• 2 TSOP Obstacle Sensors
• 1 DC Geared Motor(500mA,6v)
• Few mechano parts or any kind of aluminum strips

Keep in mind that we are building a bot for white colored arena bordered by a black line.
We would be using 4 obstacle sensors and 1 line sensor for building our bot.

Here are the sensor placements I have chosen.

The 2 sensors at the front (sensors 4 & 5) can also be replaced by one sensor but in such a case detecting the dustbin would be slightly difficult.

With this, you could very easily lift things and throw it into the dustbins.
I have added a long but robust framework to my bot built with mechano parts. Kids might find it difficult 2 build it, but after all, it’s a necessity.
Note that the length of “x” if quite large as the bucket has to come back to drop the object too. Also, I have used gears to increase the torque of the motor. Even after adding gears, if the torque isn’t enough, you could add counter weights.

This is what my final bull looked like:

ALGORITHM:
So, any idea what the algorithm would look like?
If this is what you guessed you are surely a genius!
• If sensor1 is on, go straight till sensor4 detects object.
• If sensor1 is off, come back and turn.
• If sensor 2 is detecting, come back and turn right.
• If sensor3 is detecting, come back and turn left.
• If sensor4 is detecting, pick the object.

• If sensor5 is detecting turn right slightly.

Note- All Obstacle Sensors bought from TRI are active low sensors, so “detecting” would mean the sensor is OFF.

PROGRAMCODE:

BEGIN
{
FOREVER
{
IF(SENSOR1 IS OFF) // If boundary is detectd then

{ go back and turn.
RIGHTMOTOR(BACKWARD,100);
LEFTMOTOR(BACKWARD,100);
WAIT(1 SEC);
RIGHTMOTOR(FORWARD,80); //lower RPM used to avoid
Skidding.
LEFTMOTOR(BACKWARD,80);
WAIT(1 SEC);
}

ELSE // Keep moving forward
{
RIGHTMOTOR(FORWARD,100);
LEFTMOTOR(FORWARD,100);
}
IF(SENSOR4 IS OFF) // If object is in front.
{
WAIT (700); //continue to go forward for 700
milliseconds so that the shovel

reaches the object.
CENTREMOTOR (FORWARD,70); // pick up the object
WAIT(1 SEC);
CENTREMOTOR (0,0);
FOREVER
{
IF(SENSOR1 IS OFF) // Check if you have detected the
boundary.
{

RIGHTMOTOR(BACKWARD,100); //Come back and turn to
LEFTMOTOR(BACKWARD,100); stay in the arena.
WAIT(1 SEC);

RIGHTMOTOR(FORWARD,80); //lower RPM used to avoid
Skidding.
LEFTMOTOR(BACKWARD,80);
WAIT(1 SEC);
}
ELSE // keep going straight.

{
RIGHTMOTOR(FORWARD,100);
LEFTMOTOR(FORWARD,100);
}

IF(SENSOR5 IS OFF) //dustbin is in front.
{
WAIT(450); //continue going forward so that shovel is near the bin.
RIGHTMOTOR(0,0);
LEFTMOTOR(0,0);

CENTREMOTOR(BACKWARD,50); // Lower down the
WAIT(1300); shovel to place object
CENTREMOTOR(0,0); in front of dustbin.
RIGHTMOTOR(BACKWARD,100); // go back.
LEFTMOTOR(BACKWARD,100);
WAIT(500);
RIGHTMOTOR(0,0);
LEFTMOTOR(0,0); CENTREMOTOR(FORWARD,50); // raise shovel.
WAIT(1 SEC);

CENTREMOTOR(0,0);
RIGHTMOTOR(FORWARD,100); // go forward to push
the object into the
bin.
LEFTMOTOR(FORWARD,100);
WAIT(1 SEC);
RIGHTMOTOR(BACKWARD,100); // come back.
LEFTMOTOR(BACKWARD,100);
WAIT(1 SEC);

FOREVER //After the task is done
{ stay in standstill position.
RIGHTMOTOR(0,0);
LEFTMOTOR(0,0);
}
}

IF(SENSOR2 IS OFF) // If the right obstacle sensor detects
the dustbin
{

RIGHTMOTOR(BACKWARD,100); // Come back.
LEFTMOTOR(BACKWARD,100);
WAIT(1000);
WHILE(SENSOR5 IS ON) // turn right till
sensor5 detects bin.
{
LEFTMOTOR(FORWARD,80); // to avoid skidding.
RIGHTMOTOR(BACKWARD,80);
} // once sensor5 detects

the object stop turning.

}
IF(SENSOR3 IS OFF) // If the left obstacle
sensor detects the
dustbin.
{
RIGHTMOTOR(BACKWARD,100); // Come back.
LEFTMOTOR(BACKWARD,100);
WAIT(1000);

WHILE(SENSOR5 IS ON) //turn left till front obstacle
sensor5 detects the bin.
{
LEFTMOTOR(BACKWARD,80); //lower RPM used to
RIGHTMOTOR(FORWARD,80); avoid skidding.
} // once sensor5 detects the bin
stop turning
}
}

} // forever loop closed
IF(SENSOR2 IS OFF) // If the right obstacle sensor detects the
object.
{
RIGHTMOTOR(BACKWARD,100); // Come back and turn right till front obstacle sensor5
detects the object.
LEFTMOTOR(BACKWARD,100);
WAIT(1000);
WHILE(SENSOR5 IS ON)

{
LEFTMOTOR(FORWARD,100);
RIGHTMOTOR(BACKWARD,100);
} // once front obstacle sensor5
detects object stop turning
}

IF(SENSOR3 IS OFF) // If the left obstacle sensor detects the object.
{
RIGHTMOTOR(BACKWARD,100); // Come back and turn till

LEFTMOTOR(BACKWARD,100); front obstacle SENSOR 5
WAIT(1000); detects the object.
WHILE(SENSOR5 IS ON)
{
LEFTMOTOR(BACKWARD,100);
RIGHTMOTOR(FORWARD,100);
} // once front obstacle sensor5 detects
object stop turning.
}

IF(SENSOR5 IS OFF) // If front obstacle sensor detects the object then turn
slightly to make SENSOR4 detect the object.
{
RIGHTMOTOR(BACKWARD,100);
LEFTMOTOR(FORWARD,100);
WAIT(34);
}
}
} END

To catch a glimpse of what your i-MACH DOZER is up to,check out this video.

http://www.youtube.com/watch?v=Rg1swZtBR_g

So go on and build one for yourself, and do remember 2 give it a cool, funky, and a raging look!
You may read my program once and try to understand the logic. If your program isn’t working you may refer the above one for debugging. THERE IS NOTHING AS GOOD AS TO SEE YOUR FIRST VERY OWN COMPLEX PROGRAM WORK. So please DO NOT blindly copy the above program.
Also, you could build a gripper with the same algorithm and program, only the gripping mechanism is to be added. Do remember to adjust the “wait” or “delay” command of the gripper motor in such a way that the gripper could hold the object easily.
So go on and try it out! Everything need not be copied, you could very much use your imagination and build cooler stuffs. We too are open for your suggestions, which could be posted in the forums.

Here is what the grid looks like:

The first thing that strikes me is that maybe I can develop on the concept of a line sensor. So I use three of the IR sensors.

Thought process:

The most basic way to detect a junction would be that if all the three sensors detect the black line then, a junction has been reached and for other areas it acts like a basic line follower. If the right sensor detect the line then turn right and if the left sensor detects a line then turn left.

Algorithm:


1: start
2: if IR1, IR3 on WHITE AND IR2 on BLACK
3: then GO FWD
4: if IR1 on BLACK AND IR2, IR3 on WHITE
5: then TURN LEFT
6: if IR3 on BLACK AND IR1, IR2 on WHITE

7: then TURN RIGHT
8: if IR1, IR2, IR3 on BLACK
9: then (junction detected)
10: go BACK to STEP 2
11: end


So now that we have detected the junction we can program the robot to go left and right alternately on each junction to reach the other corner of the grid. Try it out!

You can use basic black electric tape to make the grid on the floor.

Consider a grid, we want the robot to move from one corner of the grid to another. The most important part of being able to do so would be to detect a junction. Let us see if we can do this…

Here is what the grid looks like:

The first thing that strikes me is that maybe I can develop on the concept of a line sensor. So I use three of the IR sensors.

Thought process:

The most basic way to detect a junction would be that if all the three sensors detect the black line then, a junction has been reached and for other areas it acts like a basic line follower. If the right sensor detect the line then turn right and if the left sensor detects a line then turn left.

Algorithm:


1: start
2: if IR1, IR3 on WHITE AND IR2 on BLACK
3: then GO FWD
4: if IR1 on BLACK AND IR2, IR3 on WHITE
5: then TURN LEFT
6: if IR3 on BLACK AND IR1, IR2 on WHITE

7: then TURN RIGHT
8: if IR1, IR2, IR3 on BLACK
9: then (junction detected)
10: go BACK to STEP 2
11: end


So now that we have detected the junction we can program the robot to go left and right alternately on each junction to reach the other corner of the grid. Try it out!

You can use basic black electric tape to make the grid on the floor.

Photovore is a robot that moves towards bright light.

Here we will be making a photovore using the iPitara kit. We will need a “Light Sensor” for making this. To make a light sensor we will use something called LDR or a Light Dependant Resistance.

It is basically a resistance, but this resistance changes with change in ambient light. More the light lesser is the resistance. We can use this property to be able to detect how much light is there around the robot.

We will use this circuit to make 2 light sensors.

Using this circuit, a simple Light Sensor module can be made:

Connecting this to the iPitara kit:

Basically what happens is that, as the intensity of light changes, the resistance of the LDR changes and this changes the voltage at the DATA pin. This voltage is measured by the iPitara kit and we can get a calibration value for the LDR using the built-in “Calibrate” function of the iPitara kit.

The circuit is basically a Voltage divider network. Read more about it on Wikipedia here.

Now for the programming: (click to enlarge)

Work done by-Krishna Kumar Rao, Std.X
How cool would it be if u could upgrade your i-MACH by adding basic mechano parts and some brains into complex robots! Here i would be teaching (or rather guiding) you to build one yourself.
Bull Dozer
Now, let’s take a step forward and build an autonomous Bull Dozer! Let me tell you this could take some time……….so BE PREPARED!
Well, what all features would you want to be included in your Bull Dozer? If they are these, then you are at the right place.
• Could sense the object.
• Pick it up on its own.

• Throw it into the dustbin!(or any other place u want to).
Building one would require a few extra parts which are not included in the
i-MACH kit. The list of such parts is given below-
• 2 TSOP Obstacle Sensors
• 1 DC Geared Motor(500mA,6v)
• Few mechano parts or any kind of aluminum strips

Keep in mind that we are building a bot for white colored arena bordered by a black line.
We would be using 4 obstacle sensors and 1 line sensor for building our bot.

Here are the sensor placements I have chosen.

The 2 sensors at the front (sensors 4 & 5) can also be replaced by one sensor but in such a case detecting the dustbin would be slightly difficult.

With this, you could very easily lift things and throw it into the dustbins.
I have added a long but robust framework to my bot built with mechano parts. Kids might find it difficult 2 build it, but after all, it’s a necessity.
Note that the length of “x” if quite large as the bucket has to come back to drop the object too. Also, I have used gears to increase the torque of the motor. Even after adding gears, if the torque isn’t enough, you could add counter weights.

This is what my final bull looked like:

ALGORITHM:
So, any idea what the algorithm would look like?
If this is what you guessed you are surely a genius!
• If sensor1 is on, go straight till sensor4 detects object.
• If sensor1 is off, come back and turn.
• If sensor 2 is detecting, come back and turn right.
• If sensor3 is detecting, come back and turn left.
• If sensor4 is detecting, pick the object.

• If sensor5 is detecting turn right slightly.

Note- All Obstacle Sensors bought from TRI are active low sensors, so “detecting” would mean the sensor is OFF.

PROGRAMCODE:

BEGIN
{
FOREVER
{
IF(SENSOR1 IS OFF) // If boundary is detectd then

{ go back and turn.
RIGHTMOTOR(BACKWARD,100);
LEFTMOTOR(BACKWARD,100);
WAIT(1 SEC);
RIGHTMOTOR(FORWARD,80); //lower RPM used to avoid
Skidding.
LEFTMOTOR(BACKWARD,80);
WAIT(1 SEC);
}

ELSE // Keep moving forward
{
RIGHTMOTOR(FORWARD,100);
LEFTMOTOR(FORWARD,100);
}
IF(SENSOR4 IS OFF) // If object is in front.
{
WAIT (700); //continue to go forward for 700
milliseconds so that the shovel

reaches the object.
CENTREMOTOR (FORWARD,70); // pick up the object
WAIT(1 SEC);
CENTREMOTOR (0,0);
FOREVER
{
IF(SENSOR1 IS OFF) // Check if you have detected the
boundary.
{

RIGHTMOTOR(BACKWARD,100); //Come back and turn to
LEFTMOTOR(BACKWARD,100); stay in the arena.
WAIT(1 SEC);

RIGHTMOTOR(FORWARD,80); //lower RPM used to avoid
Skidding.
LEFTMOTOR(BACKWARD,80);
WAIT(1 SEC);
}
ELSE // keep going straight.

{
RIGHTMOTOR(FORWARD,100);
LEFTMOTOR(FORWARD,100);
}

IF(SENSOR5 IS OFF) //dustbin is in front.
{
WAIT(450); //continue going forward so that shovel is near the bin.
RIGHTMOTOR(0,0);
LEFTMOTOR(0,0);

CENTREMOTOR(BACKWARD,50); // Lower down the
WAIT(1300); shovel to place object
CENTREMOTOR(0,0); in front of dustbin.
RIGHTMOTOR(BACKWARD,100); // go back.
LEFTMOTOR(BACKWARD,100);
WAIT(500);
RIGHTMOTOR(0,0);
LEFTMOTOR(0,0); CENTREMOTOR(FORWARD,50); // raise shovel.
WAIT(1 SEC);

CENTREMOTOR(0,0);
RIGHTMOTOR(FORWARD,100); // go forward to push
the object into the
bin.
LEFTMOTOR(FORWARD,100);
WAIT(1 SEC);
RIGHTMOTOR(BACKWARD,100); // come back.
LEFTMOTOR(BACKWARD,100);
WAIT(1 SEC);

FOREVER //After the task is done
{ stay in standstill position.
RIGHTMOTOR(0,0);
LEFTMOTOR(0,0);
}
}

IF(SENSOR2 IS OFF) // If the right obstacle sensor detects
the dustbin
{

RIGHTMOTOR(BACKWARD,100); // Come back.
LEFTMOTOR(BACKWARD,100);
WAIT(1000);
WHILE(SENSOR5 IS ON) // turn right till
sensor5 detects bin.
{
LEFTMOTOR(FORWARD,80); // to avoid skidding.
RIGHTMOTOR(BACKWARD,80);
} // once sensor5 detects

the object stop turning.

}
IF(SENSOR3 IS OFF) // If the left obstacle
sensor detects the
dustbin.
{
RIGHTMOTOR(BACKWARD,100); // Come back.
LEFTMOTOR(BACKWARD,100);
WAIT(1000);

WHILE(SENSOR5 IS ON) //turn left till front obstacle
sensor5 detects the bin.
{
LEFTMOTOR(BACKWARD,80); //lower RPM used to
RIGHTMOTOR(FORWARD,80); avoid skidding.
} // once sensor5 detects the bin
stop turning
}
}

} // forever loop closed
IF(SENSOR2 IS OFF) // If the right obstacle sensor detects the
object.
{
RIGHTMOTOR(BACKWARD,100); // Come back and turn right till front obstacle sensor5
detects the object.
LEFTMOTOR(BACKWARD,100);
WAIT(1000);
WHILE(SENSOR5 IS ON)

{
LEFTMOTOR(FORWARD,100);
RIGHTMOTOR(BACKWARD,100);
} // once front obstacle sensor5
detects object stop turning
}

IF(SENSOR3 IS OFF) // If the left obstacle sensor detects the object.
{
RIGHTMOTOR(BACKWARD,100); // Come back and turn till

LEFTMOTOR(BACKWARD,100); front obstacle SENSOR 5
WAIT(1000); detects the object.
WHILE(SENSOR5 IS ON)
{
LEFTMOTOR(BACKWARD,100);
RIGHTMOTOR(FORWARD,100);
} // once front obstacle sensor5 detects
object stop turning.
}

IF(SENSOR5 IS OFF) // If front obstacle sensor detects the object then turn
slightly to make SENSOR4 detect the object.
{
RIGHTMOTOR(BACKWARD,100);
LEFTMOTOR(FORWARD,100);
WAIT(34);
}
}
} END

To catch a glimpse of what your i-MACH DOZER is up to,check out this video.

http://www.youtube.com/watch?v=Rg1swZtBR_g

So go on and build one for yourself, and do remember 2 give it a cool, funky, and a raging look!
You may read my program once and try to understand the logic. If your program isn’t working you may refer the above one for debugging. THERE IS NOTHING AS GOOD AS TO SEE YOUR FIRST VERY OWN COMPLEX PROGRAM WORK. So please DO NOT blindly copy the above program.
Also, you could build a gripper with the same algorithm and program, only the gripping mechanism is to be added. Do remember to adjust the “wait” or “delay” command of the gripper motor in such a way that the gripper could hold the object easily.
So go on and try it out! Everything need not be copied, you could very much use your imagination and build cooler stuffs. We too are open for your suggestions, which could be posted in the forums.

Objective:

This is a slightly more complicated application of the i-Mach kit. The main aim of this robot is to travel a designated path, detect an obstacle, pick it up and then bring it back to the starting position. The robot must be made so that the object is lifted up and then dropped back down.

This particular application, the Lifter BOT can be, and in fact in many countries has already being used in different assembly plants. Although this particular robot is an over simplified version of the actual lifters and stackers, this design could be further developed in plants where things, usually heavy objects have to be moved from one place to another on a repeated basis.

In this application, paper cups will be symbolic of the load to be lifted, and the designated path will be a black line on a white surface, hence once again a line-follower.

Description:

This robot required a special lifting device that had to be made, this has been explained more thoroughly below, however the arrangement of sensors in this bot is similar to the Fire Fighter, since the bot is a going follow a line.

Sensor1 –Right out Line Sensor

Sensor2- Left out Line Sensor(hidden behind)

Sensor3- Left in Line Sensor

Sensor4- Right in Line Sensor
Note:: there is an extra obstacle sensor used (Sensor 5) in front of the robot to detect the paper cups in front.

However the mechanism that is unique to this robot is its lifting mechanism. In order to make a rigid and stable lifting mechanism, the robot firstly had to be low and the centre of mass had to fall close to the centre of the robot. Although the load (paper cup) is not so heavy, the robot was initially designed to lift a much heavier object. Thus to achieve this, the smaller wheels with the axles were used to reduce the speed (hence increase the stability) and also maintain balance. To make a rigid lifting mechanism, two motors were used. Now the i-con board that comes with the i-Mach kit has only three motor ports, left, right and centre. Left and right ports are taken up by the driving wheels, so the only free port was the centre port. Although there is provision of the “Fan” port, this allows only unidirectional motion, we require both forward and backward motions in the case. Hence in order to use two different motors for the lifting mechanism, the two motors were combined and placed in the same port. An advantage of using this idea was that both received the same amount of voltage, hence both arms of the mechanism would move at same speed and direction.

Figure 2

As Figure 2 shows, the rpm of the motors had to be reduce considerably, so that the load carried by them could be increased. This was done by placing a pair of gears that would reduce the output rpm to increase the load.

Figure 3

Two long plates were connected to each of the larger wheel s(larger angle to turn). They were also connected to each other so that both the arms were in perfect synchronization (this is an additional benefit of using the two motors at the same port) however in order to make sure smooth lifting, the two arms had to be connected to each other. There was a 9 cm gap between the arms to lift and the length of each arm was 13 cm.

Hence when the two motors were moving forward, due to the gears the arms would go down and when they ran backwards the arms would go up.

Figure 4 – the Lifter at work

Algorithm :

The Algorithm for this is fairly simple:

Follow the line using the line sweeper mechanism i.e. using line sensors 3 & 4.

If Sensor1 is OFF then take a left turn, continue following the line.

If Sensor2 is OFF then take a right turn, continue following the line.

When both sensor 1 and sensor2 are off, then once take a left turn and then the next time take a right turn, keep taking alternating turns.

When sensor5 (obstacle) sensor is OFF, centre motor forward, wait for a particular period to pick up the cup, then centre motor backward to lift the cup to a certain height.

Go back to the initial starting position following the line and look for more cups.

Program Code:

int I=0,R;

BEGIN

{

FOREVER

{

IF (SENSOR4 IS OFF)

{

WHILE (SENSOR3 IS ON) // Line follower, sweeper logic

{

RIGHTMOTOR (FORWARD,100);

LEFTMOTOR (0,0);

}

}

IF (SENSOR3 IS OFF)

{

WHILE (SENSOR4 IS ON)

{

LEFTMOTOR (FORWARD,100);

RIGHTMOTOR (0,0);

}

}

IF (SENSOR1 IS OFF) // taking a left turn.

{

RIGHTMOTOR (FORWARD,100);

LEFTMOTOR (0,0);

WAIT (2000);

WHILE (SENSOR4 IS ON)

{

RIGHTMOTOR (FORWARD,100);

LEFTMOTOR (BACKWARD,100);

}

}

IF (SENSOR2 IS OFF) // taking a right turn.

{

LEFTMOTOR (FORWARD,100);

RIGHTMOTOR (0,0);

WAIT (2000);

WHILE (SENSOR3 IS ON)

{

LEFTMOTOR (FORWARD,100);

RIGHTMOTOR (BACKWARD,100);

}

}

IF (SENSOR1 IS OFF AND SENSOR2 IS OFF) // Reached a junction.

{

R=I%2; // % gives the remainder, in this case helps determine

whether I is odd or even.

I=I+1;

IF(R==0) // when I is even take a left turn.

{

WHILE (SENSOR4 IS OFF)

{

RIGHTMOTOR (FORWARD,100);

LEFTMOTOR (0,0);

}

}

IF(R==1) // when I is odd take a right turn (hence alternating turn pattern).

{

WHILE (SENSOR3 IS OFF)

{

LEFTMOTOR (FORWARD,100);

RIGHTMOTOR (0,0);

}

}

IF (SENSOR6 IS OFF) // Detected object ahead.

{

RIGHTMOTOR (0,0);

LEFTMOTOR (0,0);

CENTREMOTOR (FORWARD,100);

WAIT (1500); // Lifting arm goes down.

CENTREMOTOR (BACKWARD,100);

WAIT (1500);

CENTREMOTOR (0,0); // Lifting arm goes up and stays there.

RIGHTMOTOR (FORWARD,100);

LEFTMOTOR (0,0);

WAIT (300);

WHILE (SENSOR4 IS ON) // 180 degrees turn and going back to starting position.

{

RIGHTMOTOR (FORWARD,100);

LEFTMOTOR (BACKWARD,100);

}

}

}

}

END

Just check out this link for the video:

http://www.youtube.com/watch?v=wj4i7-bm1wo

Further Development:

In order to further enhance the performance of this application consider the following:

1. Increasing the load that can be lifted.

2. Dropping/placing the load at precise locations, by doing this the robot can be converted into a stacking robot.

3. Increasing the speed so that more number of obstacles can be lifted, hence improving the efficiency of the robot.

4. Making a gripper mechanism so that any size of objects can be lifted and now just one particular size

Browse through the CD that has been provided with the i-MACH kit.

For installation on windows, locate the setup file which would be available at the location /CiMPLE_Installation/windows/cimple_setup.exe

You can even download the same setup from the link http://triindia.co.in/download/cimple_setup.exe

Getting Started: Pre-installation checklist

For windows

Windows xp and above.

Performing the installation on Windows

Starting the installation

Once you choose to run the set up file, you will be guided through the installation process.

Just follow the steps as mentioned below and you will be done with the installation of CiMPLE.

Once you click on the set up file, a window as below appears

Click on ‘Next’, this takes you further

By default CiMPLE gets installed under C:\Program Files\CiMPLE directory. When this path appears as the destination folder, click on ‘Install’.

The installation process begins

Installing the dependencies

As the set up progresses, you get a prompt to install WinAVR which is an open source software development tool that is needed to run CiMPLE.

Select the language for installing WinAVR, default is english and click ‘OK’.

You will be guided through this setup.

Click on ‘Next’ and continue.

Accept the license agreement by clicking ‘I Agree’ and continue.

By default WinAVR gets installed under C:\ WinAVR-20080402rc1 directory. Once this location appears as the destination folder, click on ‘Next’.

You will be asked to choose features of WinAVR that you would like to install. Go by the default selections and click on ‘Install’.

The installation process begins

Finishing up

Once done, you will get a window as below.

Click on ‘Finish’ to end WinAVR installation.

Next end the CiMPLE installation.

Click on ‘Finish’ to end installation and start CiMPLE application. A user interface as shown below appears. You can write your CiMPLE code here.

Connecting the hardware

When you are done with writing the code, have saved it, compiled it and connect the hardware for the first time to burn your program, a message as shown below would appear

Subsequently another window as below would pop up. On this window select ‘No, not this time’ and click on ‘Next’.

Another window asking you to install automatically or from a specific location would appear. Select the option ‘Install from a list or specific location (Advanced)’ and click on ‘Next’.

Then you would be required to select a location to search for the components to be installed. Check the option ‘Include this location in the search’ and click on browse to locate the directory to be searched.

During the installation, a folder named “USBasp Driver” available in the directory CiMPLE_Installation\Windows in the CD gets copied on to your desktop, browse to this location on your desktop. Select this directory and click ‘OK’.

The USBasp driver can also be obtained from this link http://triindia.co.in/download/USBasp%20Driver.zip

Once this path appears in the location to be searched, click on ‘Next’.

The installation would then begin.

You will be prompted to choose the location of the file libusb0.sys. For the same, browse to the directory \Desktop\USBasp Driver\bin, select libusb0.sys and click ‘Open’.

This path would get included as the location to copy files from. Once done, click on ‘OK’.

This would complete the installation of the software for USBasp driver. Click on ‘Finish’ to exit the setup.

Once done with this, you can connect the hardware to your system and burn your code written in CiMPLE on to the same.

1. Remember, when building sumo-bots, the goal is to have fun. If you lose sight of this fact, you might end up giving up on a sumo-bot project if problems and frustration occur.

2. No sumo-bot is perfect; this means that sumo-bots that I make and that you make will have “problems” or “weak-spots.” But don’t let this stop you from making attempts at solving the “problems” in your sumo-bots; there are often many ways to solve or get around problems that come up.

3. If you’re new to making sumo-bots, it would be in your best interest to start with simple techniques and approaches. Simple things have much less that can go wrong than complex things. In addition, simple things can perform just as well as many complex techniques and approaches; still further, some complex approaches can cause more problems than they solve, getting confused in simple situations. Complexity and “smartness” can be beneficial, when used correctly, but for beginners, we recommend simpler techniques and approaches.

Overview

The Sumo is a competition between robots based on Japanese wrestling – “sumo” is the Japanese word for wrestling. Similar to traditional sumo matches, two opponents (robots) face each other in a ring.The objective is to stay in the ring while pushing the opposing robot out of the ring ( BLACK ).The robot that stays in the ring wins the match. Also at any point if both the rear wheels of bot go out of the ring then the bot has lost the match.

Out bots can also be called as Mini-sumo robots unlike larger battle SUMO robots, mini-sumo robots are not allowed to damage the opponent robot, they are only allowed to push it off the ring. They are small autonomous mobile robots designed specifically for sumo style competition. The mini-sumo robot competition rules restrict the robot length and width to 30 cm x 20 cm, but do not restrict its height. In addition, the robot’s can also be restricted eg: bot can’t weigh more than 500 grams.

Theory of Operation:

i-PITARA Kit comes with two IR sensors and one Touch sensor.

So keeping in mind the number of sensors available we will start building the logic.

To be effective, a mini-sumo robot must be able to do the following:

1.    Stay on the BLACK RING

2.    Hunt for the opponent

3.    Target (aim at) the opponent

4.    Attack the opponent

The following sections describe how the mini-sumo robot accomplishes these things.

Sensing the RING Edge (i.e detect the white surface)

Since your ring is black you can use one of your IR sensors (obviously) to keep the bot inside the ring, i.e. whenever it detects that the ring has ended (white surface is detected) you can program it to come back or take a turn according to your strategy.

Now if someone argues that why not use two IR sensors to be in the ring, I would say yes you can but why to use two when I can achieve it using one sensor. Also it depends upon the competition rules i.e. What if there is a rule that you can only use 2 IR one bump sensors?

Sensing the Opponent

Now the crashing part, after you use one IR sensor to keep your bot within the Black ring only one IR sensor and one touch sensor is left. Now, one can detect opponent using IR sensor but if the opponent has wrapped his bot in black or something that doesn’t allow the IR sensor to detect its presence then IR sensor will be useless in detecting the opponent. Another option is that we use Touch sensor, but the disadvantage would be my switch has to be pressed by the opponent. One can always make a mechanism or arrange links such that my touch sensor’s switch can effectively be turned ON, from an opponent coming from front or behind depending upon the strategy you decide.

Note: If using RC Servo motors are allowed in competitions then one scan the surrounding area for opponent by rotating the IR sensor.

Moving and Steering the Robot
Two motors attached to the two wheels provide the mechanism to move the robot. Steering is accomplished by rotating the wheels at different speeds. When one wheel turns slower than the other, the robot will move in an arc curving to the side of the slower turning wheel. By turning the wheels in the opposite direction of each other, the robot will rotate in place.

Here’s is a one way to make a SUMO Bot. One IR (AS1) to detect SUMO Ring, One Touch (DS2) and IR Sensor (AS6) to detect opponent.

Check the following figures for sensor placements.

Algorithm.

• START
• WHILE AS1 detects Black, M1 and M2 move forward with 50% speed.
• WHILE DS2 is ON M1 and M2 move forward with 100% speed.
• WHILE AS2 detects opponent move towards opponent i.e. move right for my configuration.
• WHILE AS2 detects White, M1 and M2 move forward for some time and take a turn for sometime
• STOP

That’s it !!!!!!!!!!!!!!!!