4 /1
Problem 1: Consider the articulated robot depicted in its 2D environment in Figure 1.
The robot consists of two moving components: The first one (in green) can rotate
around the fixed base, by an angle θ that range from 0 to 180 degrees (positive
anticlockwise), as detailed in Figure 2. The second component (in blue) can slide
linearly along the first one, by a distance ρ that ranges from 0 to 100 cm. Both
components are 1 meter long, hence the total length of the robot varies from 1 to 2
meters, as illustrated in Figure 2 as well.
The 2D environment shown in Figure 1 consists of empty space (in white) as well
as two obstacles (in grey). The left wall is vertical and located 1.414 meter left of
the base of the robot. The ceiling is horizontal and located 1.414 meter above and
immediately right of the base, as depicted.
(a) Draw the configuration space equivalent to the environment in Figure 1. Make
sure to place the angle θ on the horizontal axis and the distance ρ on the
vertical axis, as shown in Figure 3. Your drawing should show clearly the
frontier between the empty space and the obstacles. (10 marks)
2 4 /
Figure 1: The articulated robot in its 2D environment.
Figure 2: Range of control parameters for the rotational and linear components.
Figure 3: Configuration space equivalent to the environment in Fig. 1 (to be completed).
4 /3
(b) Show the details of your calculation of ρ for the smallest and largest θ values
such that the robot is in contact with the ceiling obstacle. Justify briefly the
shape of the frontier between these two poses. (5 marks)
(c) Draw atop your configuration space in part (a) the path that the A* algorithm
would find between the starting pose S (θ=30, ρ=80) and the goal pose G
(θ=100, ρ=50). Justify the result from principles. (5 marks)
(d) Suppose the motions of the robot are very imprecise. Devise a better strategy
(than using A* and follow its path) to control the robot and make sure it will
end up as close as possible from the intended goal pose. Draw the new path in
the configuration space (label it clearly, distinct from A*). Hint: You may
equip the robot with one additional sensor to help… (5 marks)
Note about Problems 2-3: In the following two exercises, you must design and
implement a program in the Webots robot simulator that we used throughout the
semester. All necessary concepts and features have been explained in class, and
you surely explored more throughout the projects… Nevertheless, feel free to
browse the Webots user guide, examples, and reference manual as may be needed.
For each exercise hereafter, create a Webots project with the same number i.e.,
“Project2” and “Project3”, that will contain your world model and robot
controller/s (and any other folders as created by Webots). As indicated earlier, you
ought to submit the entire folder (in Zip/Rar file). Make sure your code will work
anywhere (e.g., move the folder to a different disk location to test…)
As was the case before, you may use any of the available programming languages
i.e., either C, C++, Java, or Python. Once again, note that your code should look
very much the same regardless, as the same program logic should be implemented
in all cases. What matters is the design, from top-level decision logic to low-level
sensing and control directives, not the program syntax.
Moreover, while you do not need to submit a paper (other than for Problem 1), you
are required instead to include appropriate comments in your program files to
explain your approach and especially your decision logic, and any other matter of
interest as you see fit. The aim is to help the reader/instructor to better understand
and appreciate your effort and implementation, and likely enhance your grade.
Problem 2: This exercise is about combining wisely and efficiently a number of demos
and robot behaviors as provided by Webots, studied in class, and used in earlier
projects, to build a working Braitenberg vehicle.
(a) Create your world. It should look exactly like the one used in many Webots
demos, such as for instance for the bumper, encoders, gps, led, pen, and
several others. This world consists of a walled arena with a 4×4 chequered
floor and four colored cuboid obstacles. Lastly, add a solid lamp with a point
light source to your environment, somewhere near the center. (10 marks)
4 /4
(b) Use a robot similar to any of the wheeled robots seen in the above-mentioned
Webots demos. All have the same blue body and the same pair of red wheels
and their motors; the only difference is the set of sensors. You can therefore
use readily available sensors and must add any other as needed.
In the end, your robot must have at least 4 and at most 8 distance sensors, to
detect obstacles all around but mostly ahead of the robot. It must also be
equipped with one or more light sensor/s, to detect the lamp. Lastly, it must
have a single GPS device on board to report its position. (10 marks)
(c) Write your controller program. You can either modify the provided robot
controller, which is in C, or replace it by your own controller using your
programming language of choice. All code should be in a single source file.
Your controller must implement a combination of behaviours, as follows:
The robot will move straight by default. If it can detect the lamp, and it is far
enough, it will move toward it. The moment the robot gets real close to the
lamp, however, it will “forget” it, make a U-turn, and move away. When that
happens, it should print its position to the console. Then, after five seconds or
so, the robot will “remember” the lamp and resume its light-seeking
behaviour. In addition, the robot will avoid obstacles at all times, of course,
using the Braitenberg control scheme seen in some demo/s. (25 marks)
(d) Finally, use a supervisor to randomly change the location of the lamp every
seven seconds or so. In addition, the supervisor must print the new location
coordinates to the console, along with the current position of the robot, in a
message that indicates which is which. (10 marks)
Problem 3: This small exercise is about identifying and using appropriate sensors and
implementing appropriate controller logic to solve a classic problem, which is
to allow a robot to get out of a sand pit it has fallen in.
Download and unzip the escape_velocity.zip file next to this document. A
very basic controller is provided to get started. You can either modify it or
replace it by your own controller using your programming language of choice.
All this program does, after the usual initialization, is to keep the robot
moving alternately forward then backward at max speed. However, the slope
is too steep for such a simplistic approach, and so the robot cannot get out.
Check the robot documentation and, using your knowledge of sensors, identify
which you can use to allow the robot to accumulate momentum until it has
enough to get out of the pit. Program your solution in the controller, trying to
make the robot succeed as quickly as possible. Remember to explain your
logic in the code. (20 marks)