[Project 1] [Project 2] [Project 3] [Project 4]

Projects

For all of the projects other than the first, the procedure will be the same.
  1. 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.
  2. 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.
  3. 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.
  4. If you want to practice running your robot under the conditions it will run in the demo, contact me and it will be arranged.
  5. 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.
  6. 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:

  1. Place two robots on opposite sides of the course, facing in an anticlockwise direction.
  2. When switched on, the robots should follow the course in an anticlockwise direction.
  3. 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:

  1. If the robot hits an object, stop, back up, and turn away from it (this can be taken from the wall following code).
  2. 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.
  3. 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:

  1. If the robot hits an object, stop, back up, and turn away from it (this can be taken from the wall following code).
  2. 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.
  3. 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.
  4. 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.

  1. Sumo is a contest between two robots.
  2. Both robots have to follow a line to reach the sumo ring.
  3. 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.
  4. 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.
  5. 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.
  6. Any robot that completely (in the judgement of the referee) leaves the ring after entering it loses.
  7. 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]