A Car-Like Robot Reacting to a Changing Environment in Real Time

Project Description

My goal for this project was to use optimal motion planning as a precomputation step for real-time, interactive behavior. In addition to some fixed obstacles, the environment of the robot contains an obstacle that can toggle between two positions. During execution, the user can click the mouse to request that the moving obstacle switch positions. Once such a request has been made, its processing is delayed according to a simple probabilistic model. The task of the robot is to visit all the goal regions in the environment, in any order. The robot assumes that the user will try to block its progression toward the various goals; but it knows about the probabilistic model that delays changes in the position of the moving obstacle, and takes it into account in order to make, at every step, a decision which is probabilistically optimal.

Real-time action selection is achieved through storing the optimal strategy in an array of discretized configurations. There is actually one such array for each goal in the scene and for each of the two possible positions of the moving obstacle. Memory requirements can become an issue, but the real bottleneck is the time involved in the computation of this "navigation function." The examples below are based on a 48x48 environment grid with 24 possible robot orientations, which is not very detailed, and they each took over 45 minutes to compute on a SiliconGraphics Indigo machine.

The following are some notable features of the program:

• Nonholonomic, car-like motion
• Hardware discretization of the environment (using the ReadPixels function of OpenGL)
• Parsing of scene descriptions drawn with xfig
• "Cheat mode" where the user can move the robot with the mouse and then let it go
• Guarantee that the moving obstacle will never collide with the robot
• Test for "robot inside goal region"

In order to implement the "robot inside goal region" test, I came up with a way to fill the environment with polygons all around a given (convex) goal region. The algorithm I created is simple and efficient. Given a goal region with n vertices, it runs in time O(n) and generates no more than n+4 polygons, each with just three or four vertices.

Sample Runs

A blinking obstacle represents a pending user request. (The obstacle isn't really there until it stops blinking.) Each goal disappears as the robot reaches it. To make the movies longer and more interesting, the goals are reactivated once they have all been reached.