After successful completion of the course, students are able to master all the hardware and software knowledge required for building a fully autonomous racing car. This includes the control hardware (e.g. RBG depth camera, LIDAR, electronic speed controller, WIFI control, sensor and power board, single 5000mAH LiPo battery, sensor chassis, NVIDIA Jetson TX2 GPGPU computer platform) and the software stack (e.g. ROS, F1/10  simulator, AV mapping and localisation, AV planning, learning and vision).

The goal of this course is to give students an up-to-date foundation in the technologies being deployed and tested on self-driving cars, and more general mobile autonomous systems.

The goal of this course is to give students an up-to-date foundation in the technologies being deployed and tested on self-driving cars, and more general mobile autonomous systems.

This hands-on, lab-centered course is for master students interested in the fields of artificial perception, motion planning, control theory, and applied machine learning. It is also for students interested in the burgeoning field of autonomous driving. This course introduces the students to the hardware, software and algorithms involved in building and racing an autonomous race car. Every week, students take two lectures and complete an extensive hands-on lab. By Week 6, the students will have built, programmed and driven a 1/10th scale autonomous race car. By Week 10, the students will have learned fundamental principles in perception, planning and control and will race using map-based approaches. In the last 6 weeks, they develop and implement advanced racing strategies, computer vision and machine learning algorithms that will give their team the edge in the race that concludes the course.

The course has five learning modules that build on each other and include three races for evaluation:

1. Introduction to ROS, F1/10 & the Simulator: Introduction to self-driving hardware and full autonomous vehicle software stack, automatic emergency braking, LiDAR, rigid body transformation, Laplace domain dynamics, PID control for wall following.
2. Driving using Reactive Methods & RACE!: Build vehicle, tune electronic speed controller, and implement reactive driving methods such as follow the gap and complete Race 1.
3. AV Mapping & Localization: Foundations of SLAM with scan matching and particle filters, Google Cartographer SLAM, implement pure pursuit driving, and complete Race 2 using maps.
4. AV Planning: Moral Decision Making for autonomous systems, raceline optimization, planning with rapidly exploring random trees (RRT) and understanding model-predictive control (MPC).
5. Learning & Vision: Design and implement algorithms for detection and pose estimation, reinforcement learning and visual feature extraction.
6. F1/10 Grand Prix! Race 3 will include a project to implement planning and control race strategies.

Weekly/Session Schedule:

• Week 01: Introduction, using the F1/10 simulator. Lab 1: Intro to ROS
• Week 02: Systems: Automatic Emergency Braking and notions of safety. Lab 2: Safety Co-Pilot 
• Week 03: Sensing: LiDAR and rigid body transformations
• Week 04: Sensing and Actuation: Reference tracking, Laplace domain dynamics, PID. Lab 3: Wall Following robot lab 
• Week 05: Actuation: Electronic Speed Control tuning and Lab 4: Follow the Gap
• Week 06: Race preparation and Race 1.
• Week 07: Perception I: Localization by scan matching
• Week 08: Perception II: Mapping the world: SLAM and particle filters
• Week 09: Planning I: Pure pursuit
• Week 10: Planning II: Racing lines. Mid-semester Race 2 with navigation maps.
• Week 11 Ethics: Moral decision making and student debate
• Week 12 Advanced topics: Rapidly exploring random trees (RRT) and Model-Predictive Control (MPC) 
• Week 13: Computer vision: detection, pose estimation and visual feature extraction
• Week 14: Machine Learning: Neural network auto-pilots: can a machine learn to drive?
• Week 15: Guest lectures: Reinforcement Learning and Autonomous vehicles research prototypes 
• Week 16: End-of-semester race

Weekly lecture with continually accompanying lab assignments, deepening the understanding of the module content and increasing the individual problem-solving competence in autonomous racing cars. Lecture and lab: 2 x 3 hours/week. Tuesday and Thursday 9-12am, CPS Library

Plsease also have a look here and here.

Course grading: The final grade will be computed as follows

• 50% Labs:
• 30% Competition performance (mid-semester and end-of-semester) and public communication
• 5% Competition document: a 10-page document summarizing your approach to the competition (software architecture, algorithms, hardware, tests, etc), examples of performance results, etc.
• 5% Peer review: an anonymous evaluation of your work performed by your teammates. [10%] Participation in class and TA evaluation

Course Evaluation:

• For most labs, we will plug your code into a pre-set test (i.e., a benchmark).
• The test should run with your code in it. You will be told what the test is in the assignment, so you can make sure that your code at least runs. If you don’t find the test description in the assignment, tell us!
• We will examine the performance of your car. On some labs, we will ask you for a code walk-through, or even code tracing. Software quality (e.g., comments, code structure, modularity, etc) counts towards the grade.

A lab typically lasts one week, unless otherwise specified. It is assigned on the first lecture of the week, and due before the first lecture of the following week. We will download all submitted solutions before the lecture. We will also release the solution code at the same time that we download your submissions, so there is really no room for late submissions. You will use the released solutions, hereafter referred to as the reference implementation, in the following labs. This way, everybody starts every lab from the same baseline code that we know functions well..

The most important technical pre-requisite is good programming skills in C++ and Python. You will be coding or reading code in both languages. Python is easy to learn if you don’t already know it, but you will have to do that on your own time. You will also need knowledge of frequency transform concepts (e.g., Fourier or Laplace), basic matrix algebra and differential equations.