6.01
Staff/Schedule Grading Policies Collaboration Policy Archived Announcements
Progress
Course Notes Python and lib601 Circuit Part Specifications
Help Queue Piazza
Log In☰
Home / Software Lab 4 (Touched By An Angle)

Software Lab 04: Touched By An Angle

The questions below are due on Tuesday February 26, 2019; 08:25:00 PM.
 
You are not logged in.

If you are a current student, please Log In for full access to this page.
Music for this Lab
 

Files

This lab description is available as a PDF file here. The code distribution may be downloaded (in zip format) here, or by running athrun 6.01 getFiles from an Athena machine or a 6.01 lab laptop.

Goals: In this lab, we will explore an alternate controller for the "wall follower" problem, to try to improve upon our the performance of the controller from Design Lab 3.

1) Getting Started

You can work alone or with a partner in this lab, but you should both Submit all the Tutor problems. You may use any computer that reliably runs `soar` and `idle`.

2) Wall Follower

In Design Lab last week, we explored the "wall follower" problem: trying to get the robot to drive parallel to a wall, keeping the wall a fixed distance to its right. Last week, we saw that using a simple controller to set the robot's angular velocity proportional to the robot's error in distance did not work particularly well1. This week, we will explore alternative strategies for this problem.

3) Looking Back

Run your code from last week in the soar simulator (not the real robot) in the wallFollowerWorld.py simulation world.

Check Yourself 1:
What was the problem with last week's controller? How did the robot's behavior depend on the gain K? What was the robot doing at the moment the distance to the wall was correct?

Part of the problem with the controller from last week was that, when the robot finally reached its desired distance, it was never pointed in the proper direction. Ideally, we would like the robot to be pointed parallel to the wall when it reaches its desired location.

In this lab, we will develop a controller to cause the robot to adjust its angle to be 0, but we won't directly control its distance to the wall. In design lab, we will build on this to fix our wall-following robot.

We will start by implementing a proportional controller that sets the robot's angular velocity proportional to the robot's error in angle, with a constant of proportionality K.

Check Yourself 2:
What are the units of this gain K?

4) Experimenting with the Angle Controller

Complete the soar brain in wallFollowerAngleBrain.py in this week's distribution to implement this controller. The brain should set the robot's rotational velocity proportional to the robot's error in angle, with a constant of proportionality K. Note that our desired angle is 0 radians relative to the axis of the wall.

Run your code in the soar simulator in wallFollowerWorld.py for each of the following gains: K=0.1, K=0.5, K=1, K=10. This world will start the robot 0.5 meters away from the wall, facing at an angle of \pi / 12 radians away from the wall. Let the robot run until its distance from the wall stops changing or it runs out of room.

For each of the gains above, what was the robot's distance to the wall (in meters) at the end of the run? Enter your answers accurate to within 1 centimeter. If the robot did not converge with that gain, enter None.

When K=0.1, the robot ends up at a distance:
When K=0.5, the robot ends up at a distance:
When K=1, the robot ends up at a distance:
When K=10, the robot ends up at a distance:

Check Yourself 3:
Does a positive rotational velocity cause the robot to turn clockwise or anticlockwise? Note that you can test this in soar.

Check Yourself 4:
If the robot were instead started 0.8 meters from the wall (at the same angle), to what distance would you expect the robot to converge with a gain of 10?

Check Yourself 5:
Are the results of these simulations what you would expect, given your intuition about what this controller does with different gains?

5) Modeling the Angle Controller

In this section, we will build up an LTI model for the angle controller system. As with other systems we have considered, it will be helpful to break this system down into smaller pieces in order to analyze it.

5.1) Just Angle

We will start by looking at a simpler system that models how the proportional controller changes the robot's angle in response to a set point, in the absence of forward motion. Note that this system will have a desired angle \Theta_i as its input and the robot's actual angle \Theta_o as its output.

Assume that the robot's angle is "sensed" immediately; that is, assume that the error, proportional to which the robot sets its angular velocity, is calculated from the current desired angle and the current actual angle.

Check Yourself 6:
Draw a block diagram for this system. As with other systems, it may be helpful to think about separating this system into a controller and a plant.

Enter your system functional below. Enter your answer by entering the coefficient lists associated with the numerator and denominator Polynomial instances. You may use the variables K and T to represent the proportional controller's gain and the length of the timestep, respectively. Note that, like any other Python variables, these are case-sensitive!

System Functional:
Numerator coeffs (in {\cal R}):
Denominator coeffs (in {\cal R}):

Enter a Python list containing the poles of the system. Your expression may make use of variables K and T, representing the proportional gain in the system, and the length of the timestep in seconds, respectively.

Check Yourself 7:
For what values of K will the system be stable? What's the best choice of K?

5.2) Distance From The Wall

Adjust your model so that it models not only the robot's rotation, but also how this affects the robot's distance from the wall. Assume that the robot is moving forward with a constant, fixed velocity V. As with last week's lab, make the small angle approximation that \sin\theta \approx \theta.

Note that now you will have a system whose input is the signal \Theta_i (representing the robot's desired angle), and whose output is D_o (representing the robot's actual distance from the wall).

Check Yourself 8:
How can you use your system functional from the simpler system above to help you find the system functional for this system? Draw a block diagram that makes this relationship clear.

Enter a Python list containing the poles of the system. Your expression may make use of variables K and T, representing the proportional gain in the system, and the length of the timestep in seconds, respectively.

Check Yourself 9:
What accounts for the additional pole in this system (versus our simpler angle-only system)? What effect does this have on the convergence of the system?

6) Testing our model

Now, use the framework we have developed over the last few weeks to model and then predict the behavior of the robot. In `wallFollowerAngleModel.py`, define a function `make_wall_follower_model` that takes the following inputs:
  1. the gain of the system K
  2. the starting angle \theta_o[0], in radians
  3. the starting distance from the wall d_o[0], in meters
  4. the length of a time step, in seconds
  5. the forward velocity of the robot, in meters per second

Your function should return a model of the complete system expressed in the system functional above, using the infrastructure from week 3's exercises.

We strongly recommend that you approach this problem by defining several subsystems and combining them to make the overall system. The skeleton code contains variables angle_only_model and distance_model to hold two of these systems.

You may find the lib601 documentation for the lti module helpful.

Now, using your model created by `make_wall_follower_model`, generate predictions of the robot's response to a constant desired angle of 0, using the same gains we used earlier (`K` = 0.1, 0.5, 1, and 10). Try it with gains 15 and 25, as well. Note that, in the robot, $T=0.1$ seconds.

The SystemSimulator class can be used to create simulators for any system. This simulator representation will allow us to determine the output of the system for arbitrary input. If we had a System instance called x, for example, we could make a simulator for that system with: sim = SystemSimulator(x). Then we could find the system's response to a particular input by calling its get_response method

Remember that in wallFollowerWorld, the starting distance is 0.5 m and the starting angle is \frac{\pi}{12} radians (for accurate results, you will need to replicate these initial conditions in your simulations).

For each of these gains, enter the final distance from the robot to the wall (in meters).

Enter your answers accurate to within 1 centimeter. If the robot does not converge with that gain, enter None.

When K=0.1, the robot ends up at a distance:
When K=0.5, the robot ends up at a distance:
When K=1, the robot ends up at a distance:
When K=10, the robot ends up at a distance:
When K=15, the robot ends up at a distance:
When K=25, the robot ends up at a distance:

Check Yourself 10:
Can you make an argument for the behavior you observed in your LTI simulation and in soar, based on the poles of the system?

Check Yourself 11:
The results for K=25 are particularly surprising. Are they physically realistic? What assumption that we made in our modeling breaks down in this case?


 
Footnotes

1In fact, we were able to prove mathematically that our proportional controller setup from last week could not lead to convergent behavior, regardless of the value we chose for the gain K! (click to return to text)