[Project 1]
[Project 2]
[Project 3]
[Project 4]
Projects
For all of the projects other than the first, the procedure will be the same.
- The project requires you to create a robot that achieves a
given task. This task is described below. If anything is unclear, you should
email me for clarification.
- You have several weeks to get together with the other member of
your group to build a robot and write a program that allows the robot
to achieve the task.
- On the day identified on the syllabus page, we will have a demo session in class in
which you will demonstrate how your robot runs.
- If you want to practice running your robot under the conditions
it will run in the demo, contact me and it will be arranged.
- Each time we have such a demo session, we will spend at least
one hour of the class working on the robots. This is enough time to
tune the performance of your robot, *not* to build and program
it from scratch.
- The week after a demo session, you must hand in to me a copy of the
code your robot used in the competition.
[Project 1]
[Project 2]
[Project 3]
[Project 4]
Project 1
The first project will not require any preparation. The project requires you
complete a set of simple exercises.
These exercises will help you to become familiar with the robots and
how to program them.
[Project 1]
[Project 2]
[Project 3]
[Project 4]
Project 2
The second project is to write a program for the robot so that the
robot can take part in a pursuit race around a circular course --- the
course is marked out as a black line on a white background.
The pursuit race will work like this:
- Place two robots on opposite sides of the course, facing in an
anticlockwise direction.
- When switched on, the robots should follow the course in an
anticlockwise direction.
- If one robot touches the back of the other robot (having caught
it up) within a 3 minute period, and then stops, that robot is
declared the winner. Otherwise the robots draw.
The competition will involve a tournament of these one on one races.
The code from this project must be handed in during the lecture the
week after the competition.
[Project 1]
[Project 2]
[Project 3]
[Project 4]
Project 3
This exercise is intended to experiment with some flocking behaviors
(which we will talk about in the Reactive and Hybrid agents class). We
will program the robots with some simple rules describing how they
should behave, and then (hopefully) see larger scale behaviors emerge
from the interaction.
We will try several different experiments, and they will require you
to write a couple of different programs. However, there will be a
common core to all the code.
As ever, this will work best if you write the code before you come to the
practical.
The robot itself needs to be modified so that the light sensor "looks" forward
along the robot chassis rather than down at the ground.
I will also be giving you a light which will be attached to the robot
--- this will have its own power supply (so you don't have to worry
about doing anything in your code).
The first program you will need has the following behaviors:
- If the robot hits an object, stop, back up, and turn away from it (this
can be taken from the wall following code).
- If the robot can't detect a light source in front of it (ie a
higher reading than the background), it should turn until does.
- If the robot can detect a light source in front of it, it should
move towards it.
These behaviors should be connected so that each one takes priority
over every higher numbered layer.
Your code should be written in the reactive/subsumption architecture style. In
practice that means:
The second program adds some additional functionality:
- If the robot hits an object, stop, back up, and turn away from it (this
can be taken from the wall following code).
- If the robot can't detect a light source in front of it (ie a
higher reading than the background), it should turn until does.
- If the robot detects a light source in front of it and the light is above
a certain threshold value, it should stop, and back up.
- If the robot can detect a light source in front of it and the
light is below the threshold value, it should move towards it.
Again these behaviors should be connected as in the examples given
above, and in such a way that each one takes priority over every
higher numbered layer.
The code from this exercise must be handed in during the lecture the
week after the practical class.
[Project 1]
[Project 2]
[Project 3]
[Project 4]
Project 4
The final project will be Robot Tag.
The Tag course is as below:
The course will be built on a large piece of foamcore. About a third
of this will be the tag ring, marked by a rectangle of black
electrical tape (which is narrower than the line you followed before,
but looks much the same to the light sensor).
Each robot will have to follow a winding path to the ring from its
start position. This path will be (almost) exactly the same for both
robots.
The point at which the path meets the ring will be marked with a
square of aluminium foil; this gives a light reading above that of the
white foamcore and is typically very easy to detect.
Each robot will have to carry the same light source we used for the
previous project so that both robots can "see" each other.
The rules of the tag contest are as follows.
- Tag is a contest between two robots.
- The contest has two rounds. In each round one robot is nominated
"pursuer" and the other is nominated "evader". Each robot plays one
round as puruser and one as evader.
- Both robots have to follow a line to reach the ring.
- Robots have two minutes to reach the ring. If one robot fails to
reach the ring two minutes after the start of a contest, that robot
loses the contest.
- If both robots fail to reach the ring within the two minute
limit, the one that is closest to the ring when two minutes have
passed will be deemed the winner.
- The pursuer robot has until the 3rd minute after the start of the
round to tag (touch) the evader robot.
- If the pursuer tags the evader within the 3 minutes, the pursuer wins.
- If the pursuer cannot tag the evader within the 3 minutes, the
evader wins.
- Any robot that completely (in the judgement of the
referee) leaves the ring after entering it loses.
Obviously you will need two lights sensors for this project, so design
your program with this in mind.
You should write your program in the BDI style. Here is an example
The code from this exercise must be handed in during the lecture the
week after the practical class.
[Project 1]
[Project 2]
[Project 3]
[Project 4]