This project will entail using Webots, an open-source robotics simulation software, to learn more about control methods for autonomous vehicles. Webots was chosen because of its ease of use, flexibility, and impressive rendering capability. Please see the links on the previous page of this document for a download link, more information, and documentation.

As you might already know, Buggy is a time-honored CMU tradition (you can learn more about it here and here). Unfortunately, it was not able to be held in-person this year due to the pandemic. To help make up for this, you will be asked to create a controller that helps a vehicle to complete the same course in simulation. However, instead of controlling an actual Buggy, youll be controlling a Tesla Model 3. Its a bit more fun and stylish (we hope)!

We will follow the steps listed below to learn more about the system and synthesize several different kinds of controllers:

- Examine the provided nonlinear control model
- Linearize the state space system equations [P1]
- Develop a PID controller for the system [P1]
- Check the controllability and stabilizability of the system [P2]
- Design a full-state feedback controller using pole placement [P2]
- Design an optimal controller [P3]
- Implement an extended Kalman filter (EKF) for simultaneous localization and mapping (SLAM) [P4]

The project has been divided into 4 parts to reflect this:

P1 (a) Linearize the state space model

(b) Design a PID lateral and PID longitudinal controller

P2 (a) Check the controllability and stabilizability of the linearized system

(b) Design a lateral full-state feedback controller

P3 (a) Design an lateral optimal controller

P4 (a) Implement EKF SLAM to control the vehicle without default sensor input

(b) Race with other Buggy competitors in the class

# 2 Model

Figure 1: Bicycle model[2]

Figure 2: Tire slip-angle[2]

We will make use of a bicycle model for the vehicle, which is a popular model in the study of vehicle dynamics. Shown in Figure 1, the car is modeled as a two-wheel vehicle with two degrees of freedom, described separately in longitudinal and lateral dynamics. The model parameters are defined in Table 2.

## 2.1 Lateral dynamics

Ignoring road bank angle and applying Newtons second law of motion along the y-axis:

*ma**y *= *F**yf *cos*f *+ *F**yr*

whereis the inertial acceleration of the vehicle at the center of geometry in the direction of the y axis, *F _{yf }*and

*F*are the lateral tire forces of the front and rear wheels, respectively, and

_{yr }*is the front wheel angle, which will be denoted as*

_{f }*later. Two terms contribute to*

*a*: the acceleration

_{y}*y*, which is due to motion along the y-axis, and the centripetal acceleration. Hence:

*a*=

_{y }*y*+

^{}

*x*

Combining the two equations, the equation for the lateral translational motion of the vehicle is obtained as:

Moment balance about the axis yields the equation for the yaw dynamics as

*I* *z *= *l**fF**yf * *l**rF**yr*

The next step is to model the lateral tire forces *F _{yf }*and

*F*. Experimental results show that the lateral tire force of a tire is proportional to the slip-angle for small slip-angles when vehicles speed is large enough i.e. when

_{yr}*x*0

*.*5 m/s. The slip angle of a tire is defined as the angle between the orientation of the tire and the orientation of the velocity vector of the vehicle. The slip angle of the front and rear wheel is

*f *= * * *V f*

*r *= *V r*

where * _{V p }*is the angle between the velocity vector and the longitudinal axis of the vehicle, for

*p*{

*f,r*}. A linear approximation of the tire forces are given by

!

where *C _{ }*is called the cornering stiffness of the tires. If

*x <*0

*.*5 m/s, we just set

*F*and

_{yf }*F*both to zeros.

_{yr }## 2.2 Longitudinal dynamics

Similarly, a force balance along the vehicle longitudinal axis yields:

*x* = ^{}*y* + *a _{x}*

*ma _{x }*=

*F*

*F*=

_{f }F_{f }*fmg*

where *F *is the total tire force along the x-axis, and *F _{f }*is the force due to rolling resistance at the tires, and

*f*is the friction coefficient.

## 2.3 Global coordinates

In the global frame we have:

*X* = *x* cos* * *y* sin

*Y* = *x* sin* *+ *y* cos

## 2.4 System equation

Gathering all of the equations, if *x * 0*.*5 m/s, we have:

*Y* = *x* sin* *+ *y* cos

otherwise, since the lateral tire forces are zeros, we only consider the longitudinal model.

## 2.5 Measurements

The observable states are:

*x*

*y*

*y *= _{ }

*X*

*Y *

## 2.6 Physical constraints

The system satisfies the constraints that:

*F *> 0 and *F *6 15736 *N*

*x* > 10^{5 }*m/s*

Table 1: Model parameters.

Name | Description | Unit | Value |

(x, y) |
Vehicles velocity along the direction of vehicle frame | m/s | State |

(X,Y ) |
Vehicles coordinates in the world frame | m | State |

, ^{} |
Body yaw angle, angular speed | rad, rad/s | State |

or _{f} |
Front wheel angle | rad | State |

F |
Total input force | N | Input |

mass | |||

l_{f} |
Length from front tire to the center of mass | m | 1.55 |

C_{}I_{z} |
25854 | ||

F_{pq} |
p {x,y},q {f,r} |
||

f |
sec |

# 3 Resources

## 3.1 Simulation

Figure 3: Simulation code flow

Several files are provided to you within the controllers/main folder. The main.py script initializes and instantiates necessary objects, and also contains the controller loop. This loop runs once each simulation timestep. main.py calls your controller.pys update method on each loop to get new control commands (the desired steering angle, , and longitudinal force, *F*). The longitudinal force is converted to a throttle input, and then both control commands are set by Webots internal functions. The additional script util.py contains functions to help you design and execute the controller. The full codeflow is pictured in Figure 3.

Please design your controller in the your controller.py file provided for the project part youre working on. Specifically, you should be writing code in the update method. Please **do not **attempt to change code in other functions or files, as we will only grade the relevant your controller.py for the programming portion. However, you are free to add to the CustomController classs init method (which is executed once when the CustomController object is instantiated).

## 3.2 BaseController Background

The CustomController class within each your controller.py file derives from the BaseController class in the base controller.py file. The vehicle itself is equipped with a Webots-generated GPS, gyroscope, and compass that have no noise or error. These sensors are started in the BaseController class, and are used to derive the various states of the vehicle. An explanation on the derivation of each can be found in the table below.

Table 2: State Derivation.

Name | Explanation |

(X,Y ) |
From GPS readings |

## 3.3 Trajectory Data

The trajectory is given in buggyTrace.csv. It contains the coordinates of the trajectory as (*x,y*). The satellite map of the track is shown in Figure 4.

Figure 4: Buggy track[3]

# 4 P1: Problems

**Exercise Model Linearization. **As mentioned in class, model linearization is always the first step for non-linear control. During this assignment, you will approximate the given model with a linear model.

Since the longitudinal term *x *is non-linear in the lateral dynamics, we can simplify the controller by controlling the lateral and longitudinal states separately. You are required to write the system dynamics in linear forms as *s*_{1 }= *A*_{1}*s*_{1 }+*B*_{1}*u *and *s*_{2 }= *A*_{2}*s*_{2 }+*B*_{2}*u *in terms of the following given input and states:

**Exercise 2. Controller Synthesis in Simulation. **The driver functions that control the car take the desired steering angle * *and a throttle input ranging from 0 to 1 which is derived from the desired longitudinal force *F*.

For this question, you have to design a PID longitudinal controller and a PID lateral controller for the vehicle. A PID is an error-based controller that requires tuning proportional, integral, and derivative gains.

Design the two controllers in your controller.py. You can make use of Webots builtin code editor, or use your own.

Check the performance of your controller by running the Webots simulation. You can press the play button in the top menu to start the simulation in real-time, the fast-forward button to run the simulation as quickly as possible, and the triple fast-forward to run the simulation without rendering (any of these options is acceptable, and the faster options may be better for quick tests). If you complete the track, the scripts will generate a performance plot via matplotlib. This plot contains a visualization of the cars trajectory, and also shows the variation of states with respect to time.

Submit your controller.py and the final completion plot as described on the title page. Your controller is **required **to achieve the following performance criteria to receive full points:

- Time to complete the loop = 400 s
- Maximum deviation from the reference trajectory = 10.0 m
- Average deviation from the reference trajectory = 5 m

Some hints that may be useful:

- Using a PID controller requires storing variables between method calls. Python allows this through use of the self preface (in other words, making them class member variables). Think about which variables you use in your controller that you will need to store, and be sure to add them to CustomControllers init method so they are initialized.
- If you are tuning your lateral controller for a point on the trajectory that is the closest to the vehicle, the controller may struggle on sudden turns. Think about how to add some mechanism that looks ahead of your current position before calculating a control command. Functions in py might be useful.
- If your car does not perform well, it may just be that it requires tuning. You may already have some experience tuning PID controllers, but if not, viewing online resources is recommended. See this Wiki link[4] for more background in the process of manual tuning.

# 5 Reference

- Rajamani Rajesh. Vehicle Dynamics and Control. Springer Science & Business Media, 2011.
- Kong Jason, et al. Kinematic and dynamic vehicle models for autonomous driving control design. Intelligent Vehicles Symposium, 2015.
- org, https://cmubuggy.org/reference/File:Course_hill1.png
- PID Controller Manual Tuning.
*Wikipedia*, Wikimedia Foundation, August 30th,

2020. https://en.wikipedia.org/wiki/PID_controller#Manual_tuning

## Reviews

There are no reviews yet.