[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 sinple exercises.
[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 you need will combine elements of the code for Linebot and
Bumpbot that are in the robotics sourcebook.
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. Base your code on either this
example or this example
of how to do write a program in this style. Both examples
implement the wall-following behavior.
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
By popular choice, the final project will be Robot Sumo.
The Sumo course is as below:
The course will be built on a large piece of foamcore. About a third
of this will be the sumo 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
sqaure 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 sumo contest are as follows.
- Sumo is a contest between two robots.
- Both robots have to follow a line to reach the sumo 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.
- Once in the ring, each robot will try to push the other robot out
of the ring. Robots that (in the judgement of the referee) do not
attempt to push opponents out of the ring will be deemed the loser of
the contest.
- Any robot that completely (in the judgement of the referee)
leaves the ring after entering it loses.
- If neither robot has managed to push the other out of the ring
five minutes after the start of the contest (including the two minutes
allowed for reaching the ring), then the contest will end. The winner
will be the robot that (in the judgement of the referee) came closest
to winning the contest.
Obviously you will need two lights sensors for this project. Some of
you already have two. I'll bring extras to class for those who don't
have them.
[Project 1]
[Project 2]
[Project 3]
[Project 4]