Artificial Life – Robotics Tutorials
Artificial Life – Robotics Tutorials
1. Getting Started
2. Programming in Webots
3. Building new worlds and new robots
4. More Programming – Sensors and Actuators
5. Programming the simpleBot for a simple following behaviour
6. Adding a more sophisticated sensor
7. Using the ePuck
8. Programming the ePuck for simple obstacle avoidance
9. Programming the ePuck for simple ‘Taxis’
10. Using arbitration to choose behaviours
11. Programming the ePuck for obstacle avoidance using potential fields
12. Adding ‘colour’taxis using potential fields
13. Combining potential fields
14. Transfer and testing on the Real EPuck
15. Fixing problems with the real EPuck
16. Proportional control, thrashing, PID, hysteresis, dead zones
17. The Trashcan Competition
Artificial Life – Robotics Tutorials
Getting Started – Objective: Familarity with Webots (User Guide Chapters 1-4½)
1. Click on the Webots icon!
2. Close all windows except main display window
3. Click on main display window
4. Click the ‘open file’ icon
5. Navigate to:
D:/ProgramFiles/Webots
1. Navigate to:
/projects
1. Navigate to:
/samples
1. Navigate to:
/mybot
Artificial Life – Robotics Tutorials
Getting Started – continued….
Webots has two concepts:
The World - simulates the world and the robot
The Controller - code for controlling the robot
To simulate a robot in Webots load its world model.
1. Navigate to:
/worlds
1. Click on:
mybot.wbt
Artificial Life – Robotics Tutorials
Getting Started – continued….
4 windows appear:
Console - logs important information
Code Editor - code editor for creating and compiling controllers
Scene Tree Editor - Editor for creating the world
Webots Simulator - Simulator itself
1. Close all windows except the Webots Simulator
2. Play around with the mouse controls to manipulate the viewing position
of the world
3. Shift-Click on the mouse to manipulate and move objects around
1. Click on the run button
Notice the timing display in the bottom right hand corner – shows how fast the simulator is
running compared to real time
Artificial Life – Robotics Tutorials
Getting Started – continued….
1. Click on the stop button
2. Click on the ‘Simulation’ menu item
This duplicates the icon controls
1. Click on ‘fast’ and watch the timing control
2. Click on stop
3. Click on the robot
4. Click on the ‘view’ menu item
5. Explore the different view options
1. Shift click on the robot and select ‘follow object’
Camera now follows the robot
Artificial Life – Robotics Tutorials
Getting Started – continued….
1. Click on the ‘tools’ menu item
2. Click on the ‘Preferences’
• Click on ‘general’ tab
• Always choose ‘startup mode’ as ‘stop’ and click ‘ok’
• Click on the ‘save’ button
EXERCISE 1:
Open up and play with some of the other worlds in the
Webots Projects directory and the
Webots samples directory.
Artificial Life – Robotics Tutorials
Programming In Webots - C code version
Create a local directory to hold your own worlds and controllers
• Click on the ‘Wizard’ menu item
• Click on the ‘New Project Directory’
1. Create a controller program template in C
2. On ‘Wizard’ click ‘new Robot controller
3. Build the controller
• Copy the myBot world from webots to your world directory and rename it
(including the ‘textures’ directory).
• Edit the new world and change the controller entry to your controller.
• Open your world in Webots and make sure that your controller is active.
Artificial Life – Robotics Tutorials
Programming In Webots – continued…..
EXERCISE 2:
Edit the program and type in some ‘printf’ messages at key points in the execution.
Compile, link and execute the code and check the results in the DOS console.
Example printf: printf(“In reset function….\n”);
Note: you may need to add an include statement
#include <stdio.h>
Artificial Life – Robotics Tutorials
Robot Controllers and Supervisor Controllers
A robot controller – can use C,C++,Python or Java -> controls one robot
A supervisor controller – can use C or C++ –> controls the world and one or more robots
Artificial Life – Robotics Tutorials
New Worlds and New Robots
Click on ‘Scene Tree’ in the ‘Tools’ menu
Examine:
WorldInfo
Viewpoint
Transform
Walls
Solids
And finally
Differential Wheels
Use the menu options to get documentation.
Artificial Life – Robotics Tutorials
Programming In Webots – continued…..
How to Get information from the sensors
Add the ‘include’ file for the particular sensor
e.g.
#include <webots/distance_sensor.h>
Add some device ‘handles’ or pointers globally:
e.g. in the ‘main’ function
wb_robot_init(); /* necessary to initialize webots stuff */
/* Get and enable the distance sensors. */
WbDeviceTag ir0 = wb_robot_get_device("ir0");
WbDeviceTag ir1 = wb_robot_get_device("ir1");
Now enable the sensors:
e.g. add:
wb_distance_sensor_enable(ir0, TIME_STEP);
wb_distance_sensor_enable(ir1, TIME_STEP);
Artificial Life – Robotics Tutorials
Programming In Webots – continued…..
How to Get information from the sensors – continued…..
/* Get distance sensor values */
double ir0_value = wb_distance_sensor_get_value(ir0);
double ir1_value = wb_distance_sensor_get_value(ir1);
Now print the values to the console: Now compile code,
Fix errors,
e.g. In the run function add: Revert,
And run
printf("ir0: %f ir1: %f \n",ir0_value, ir1_value);
Move an obstacle in
front of the robot to test
Artificial Life – Robotics Tutorials
Programming In Webots – continued…..
How to Drive the Actuators (wheels in this case)
Add the ‘include’ file for the particular actuator
e.g.
#include <webots/differential_wheels.h>
Define a default speed:
#define DEFAULT_SPEED 60;
In the ‘main’ function create some wheel speed variables
e.g. Now compile code,
double left_speed, right_speed; Fix errors,
Revert,
Give them some default values: And run
left_speed = DEFAULT_SPEED;
right_speed= -DEFAULT_SPEED ; // make the robot spin
In the ‘run’ function set the wheel speed
e.g.
wb_differential_wheels_set_speed(left_speed, right_speed);
Artificial Life – Robotics Tutorials
Programming In Webots – continued…..
EXERCISE 4:
• Modify the sensor reading/actuator setting code to create a robot which avoids
obstacles.
• Take some inspiration from your previous lectures/tutorials on Braitenburg
vehicles.
Artificial Life – Robotics Tutorials
Programming In Webots – continued…..
EXERCISE 5:
• Modify the sensor reading/actuator setting code to create a robot which
follows obstacles but otherwise stays still.
• Use the devC++ development system to do this
Now we will use a more sophisticated sensor – a camera
Load up camera.wbt from
c:\Program Files\Webots\projects\samples\devices\worlds
EXERCISE 6:
• Play with the simulation and study the controller code (and the webots documentation).
• Work out what you need to do to detect colour blobs
• Change the controller to allow the robot to follow a red block.
Artificial Life – Robotics Tutorials
Programming The Epuck Robot
1. Create a controller program template in C++ from the saved controller
i.e. copy webotsTemplate.cpp to joesEpuck.cpp
• Copy the e-puck.wbt world from webots to your
world
directory and rename it (e.g. joesEpuck.wbt) also copy the textures directory
• Edi
t
th
e
new world and change the controller entry to your controller (i.e. joesEpuck)
• Open your
world in
Webots and make sure that your controller is active (by adding some printf’s)
EXERCISE 7.
Artificial Life – Robotics Tutorials
Programming The Epuck Robot
EXERCISE 8.
Create an simple obstacle avoidance behaviour for the Epuck
EXERCISE 9.
Create some simple ‘taxis’ behaviour for the Epuck
e.g. this could an attraction to the red block and and repulsion from the green
block
EXERCISE 10.
Combine your behaviours using simple priority based arbitration.
Use either an ‘if –then’ construct or (more advanced) a mechanism which yields
control to the particular behaviour (hint: create each behaviour as a class
which if its ‘releasers’ are met becomes available for execution, keep the
classes in an array, highest first and loop through the array).
Artificial Life – Robotics Tutorials
Programming the ePuck for obstacle avoidance using potential fields
1. Copy your existing EPuck controller to a new controller.
2. Copy your existing EPuck world to a new world.
3. Rename the world controller, compile, link, revert and test.
EXERCISE 11 – normalising the sensors
Modify your program to print the values of the (8) IR sensors.
Write some code to normalise these values (hint: put the high and low
values as #defines so that they can be altered when we use the real
EPuck).
Rename the world controller, compile, link, revert and test.
Artificial Life – Robotics Tutorials
Programming the ePuck for obstacle avoidance using potential fields
The vector library:
Supplied is a vector class library to help. Use as follows:
To create a vector: CVector newVector(100,97);
Will create a vector of magnitude 100 and angle 97 degrees.
Adding vectors:
CVector sumV;
CVector anotherVector(200,67);
sumV = newVector +anotherVector;
Get the result:
Printf”Amgle: %f Mag: %f\n”, sumV.getDirection(),sumV.getMagnitude());
Artificial Life – Robotics Tutorials
Programming the ePuck for obstacle avoidance using potential fields
1. Measure angles of sensors on real Epuck.
2. Set up a list of vectors (8), with these angles and values of distance sensor
3. Compute sum of above
4. Use the new angle/magnitude to control the actuators
70 110
140
40
0 180
Sensor
300 240
angles
// create a set of 2 element vectors
CVector lv[8];
// fill with light sensor values and physical angle of sensor on robot
lv[0].setValues(ds_value[0],110);
lv[1].setValues(ds_value[1],140);
lv[2].setValues(ds_value[2],180);
lv[3].setValues(ds_value[3],240);
lv[4].setValues(ds_value[4],300);
lv[5].setValues(ds_value[5],0);
lv[6].setValues(ds_value[6],40);
lv[7].setValues(ds_value[7],70);
// create a resultant vector
CVector res;
for (int i=0;i<8;i++)
{
res = res + lv[i];
}
int direction = (int) res.getDirection();
int magnitude = (int) res.getMagnitude();
printf("Direction and magnitude of object: %f %f\n",res.getDirection(),res.getMagnitude());
EXERCISE 12:
Implement and test the EpuckVector.wbt world.
Artificial Life – Robotics Tutorials
Colour Blob Tracking using the Epuck Camera
The Epuck camera takes picture images.
These are returned as arrays of pixels – the array size depends on how the
camera is configured.
For a 10 (width) * 6 (height) camera – 600 pixels will be returned.
You can get the width and height using the following webots functions:
width = camera_get_width(camera);
height = camera_get_height(camera);
To obtain the image:
image = camera_get_image(camera);
(See EpuckBlob.wbt)
Artificial Life – Robotics Tutorials
Colour Blob Tracking using the Epuck Camera
Each pixel is returned as a three element code (3 integers).
The code is called RGB meaning red/green/blue.
Each integer can have a value between 0 and 255.
For more ‘redness’ the first integer would have a higher value.
For more ‘blueness’ the second integer would have a higher value.
For more ‘greenness’ the third integer would have a higher value.
Black is 255,255,255 and white is 0,0,0
To get the RGB values do the following:
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
red = camera_image_get_red(image, width, x, y);
green = camera_image_get_green(image, width, x, y);
blue = camera_image_get_blue(image, width, x, y);
}}
Artificial Life – Robotics Tutorials
Colour Blob Tracking using the Epuck Camera
To check for a red blob simply count the number of pixels in the
image that have more redness and compare that to the number of
pixels that have greeness or blueness.
If there is more redness then the camera can probably see something
red.
EXERCISE 13:
Implement and review the EpuckBlob.wbt world and try to understand how
the RGB system works.
Artificial Life – Robotics Tutorials
Using the Real Epuck
1. Turn on the EPuck
2. Find the rotation switch and switch to position 0.
On/Off
Reset
Position 0
Switch
EXERCISE 14:
Check out the other rotation positions for each internal program
Artificial Life – Robotics Tutorials
Using the Real Epuck – Connecting via Bluetooth
1. Find the rotation switch and switch to position 0.
2. Click on “My Bluetooth Places” and “View devices in Range” - see if the
robot appears
3. Connect to the robot by entering the pin code on the front of the robot.
4. Check that the Epuck is working by running the EPuck monitor program.
EXERCISE 15:
Play with the EPuck functions and camera options using the EPuck
monitor
Artificial Life – Robotics Tutorials
Using the Real Epuck – Connecting via Webots
1. Find the rotation switch and switch to position 0.
2. Start up Webots and load the Epuck.wbt world
3. Double click on the simulated Epuck.
4. Choose remote control.
5. Run the control program on Webots
EXERCISE 16:
Experiment with the real Epuck to see why it doesn’t work exactly as the
simulated version.
EXERCISE 17:
Implement a proportional controller on the simulated Epuck e.g. the nearer
the obstacle the faster the Epuck rotates. Transfer to the real Epuck and
see if you experience thrashing, hysterisis and dead zones. Code to
‘solve’ these issues.
Artificial Life – Robotics Tutorials
EXERCISE 18: TRASHCAN COMPETITION
• You should now have enought code samples and Webots experience to attempt a
competition.
• The competition is based on the subsumption architecture outlined in Robin Murphy's
book (Introduction to AI robotics) for the Trashcan competition.
• Here we will use the following: A world containing 1 red block, 1 green block and 2 yellow
blocks (as myEpuckBlob.wbt).
Rules
• Epuck starts at green block.
• Epuck searches for yellow blocks. When very close to a yellow block all led's are set on
(indicating that a yellow block has been found).
• Epuck searches for red block. When very near the red block all leds turned off (indicating
that trashcan has been found). <Yellow block removed manually>
• Repeat above for second yellow block.
• When finished return to green block.
Approach
• Ideally some for of arbitration architecture between behaviours should be implemented.
However, this could be simply a set of if-then statements.
• You can work individually or in groups.
• The potential fields approach and the blob tracking code samples may be useful,
pick and choose (or use a simpler solution) as you wish.
