Robot Simulator

The questions below are due on Sunday February 10, 2019; 11:00:00 PM.

You are not logged in.
If you are a current student, please Log In for full access to this page.

In Design Lab 1, we programmed the robot to keep itself a fixed distance away from a wall using a proportional controller, where we set the robot's velocity at a particular time n to be proportional to an error (the difference between its current distance and the desired distance):

\underbrace{v[n]}_{\text{velocity at time $n$}} = \underbrace{K}_{\text{tunable gain}} \cdot \left(\underbrace{d_m[n]}_{\text{measured distance at time $n$}} - \underbrace{d_d[n]}_{\text{desired distance at time $n$}}\right)

Check Yourself 1:

What are the units of K in this equation?

Show/Hide

$K$ is multiplied with a distance in meters to give us the velocity at time $n$ in meters per second. If we want to make the units on both side of the equation match, $K$ has to be in units of "per seconds" or Hz.

In one part of that lab, you were asked to find a value of K that worked "best," in the sense that it led the robot to converge quickly to the desired distance without "overshooting" (getting too close to the wall).

One way to tackle that is simply by trying different values of the parameter K, setting up the robot, letting it run, and observing its behavior. However, that was a time-consuming process. For us, a "test run" meant spending some extra time watching the robot run, and the cost of failure was having to set up the wall again; for many real-world applications, a failed "test run" could mean millions of dollars and several years worth of time, and so it is important to get things right!

One way we can help to make sure that we "get it right" the first time is to develop simulations of the system we are designing, and to use those simulations to help us improve our design. In this exercise, we will make our first attempt at developing a simulator for the robot system from design lab 1; over the next few weeks, we will build on this, and we will develop more general frameworks that can be used to simulate arbitrary systems. For now, a good start will be to develop a simulator for the specific problem we tackled in lab.

1) Simulator

We will write our simulator by writing a function called simulate_wall_finder, which should take the following inputs, in order:

K: the gain to use
initial_distance: the robot's initial distance from the wall, in meters
goal_distance: the robot's desired distance from the wall, in meters
dt: the length of a "timestep", in seconds
num_timestamps: the number of timesteps to consider

Your function should return a single value, representing the robot's distance from the wall after num_timesteps timesteps have passed. You may assume that the robot can change its velocity instantaneously at the start of each timestep, and that it travels at that velocity for the entirety of a timestep.

As an example,

simulate_wall_finder(2, 1.0, 0.5, 0.1, 5)

should return

0.7048

because:

On the first timestep, the robot is 1 meter away from the wall (hence the initial 1.0). At this point, it also sets its velocity to be 2*(1.0 - 0.5) = 1 m/s.
On the second timestep, the robot has been moving at a velocity of 1 m/s for 0.1 seconds, so its position is 1 - (1*0.1) = 0.9 meters. It also sets its velocity to be 2*(0.9-0.5) = 0.8 m/s.
On the third timestep, the robot has been moving at a velocity of 0.8 m/s for 0.1 seconds, so its new position is 0.9 - (0.8*0.1) = 0.82 meters. It also sets its velocity to be 2*(0.82-0.5) = 0.64 m/s.

Check Yourself 1:

Work through the math for the last two timesteps on your own.

When you are developing this function, you can use the above example as a test case to help see whether you are on the right track!

Implement and test this function on your own machine. Then, paste the output of each of the following function calls into the boxes:

simulate_wall_finder(2, 1.0, 0.5, 0.1, 5)

simulate_wall_finder(2, 0.5, 0.2, 0.1, 10)

simulate_wall_finder(0.1, 0.7, 0.3, 0.2, 100)

simulate_wall_finder(0.01, 1.5, 0.1, 0.05, 1000)

2) Detecting Overshoot

One of our goals in the lab was to prevent the robot from overshooting its goal (in the case of Design Lab 1, we wanted to prevent it from running into the stick). In the rest of this exercise, we will modify the simulator we have just built to reason about this question. In order to think about when the system overshoots, we will first develop a function that tests whether the system did overshoot in a particular case.

We will implement this test as a function overshoot, which take the same inputs as simulate_wall_finder, but instead of returning the robot's final distance, returns True if the robot overshot its goal (that is, if it ever got closer than goal_distance during the first num_timesteps timesteps), and False otherwise.

It may be helpful to test and debug this code on your own machine before pasting it into the box below:

3) Choosing Gain

Finally, use your simulator to experimentally determine the largest value of K for which the system does not overshoot when initial_distance is 1.0, goal_distance is 0.5, dt is 0.1, and num_timesteps is 5. Your answer must be accurate to within 1Hz.

Best Gain:

Check Yourself 2:

How does the value of K you found with your simulator compare against the K values you used in the real robot? What could account for these differences?

Show/Hide

It is likely that the real robot had overshoot for values of $K$ that were much smaller than 10. Most of this comes from the fact that our model does not perfectly describe the robot's motion. For example, we don't take into account the fact that the robot can "slip" when first starting up, and the idea that the robot can accelerate/decelerate to abritrary velocities instantaneously isn't quite true, either!

A common theme we will notice moving forward is that no model is perfect; the right question as we move forward is: even though the model isn't perfect, is it useful? We will build on this idea of simulation over the next couple of weeks and find that we will be able to build some very useful models and use them to inform our design when working with the robot.

Check Yourself 3:

How does the answer to K change when you vary the other parameters?