AutonomousVehicleControlBeginnersGuide

Learn autonomous driving by building it. Python simulations and an open textbook of self-driving car algorithms (localization, mapping, path planning, path tracking, perception and control), and of the software architecture that connects them into one autonomous driving system. The system grows one stage at a time, and you can swap and compare the algorithms of each stage in the same system.

Read the book · See all simulations · Quick start

Table of Contents

• About this project
• Requirements
• Quick Start
• Examples of Simulation
• The book
• License
• Citing
• Use Case
• Contribution
• Author

About this project

Every algorithm is a small Python simulation with an animation, written to be easy to read rather than fast or complete. You can run each one with a single command, change its parameters and see what happens. Fork it and use it for studying, teaching or your own work.

Beyond single algorithms, the project shows how they work together: how the stages of an autonomous driving system pass data to each other, why the true state and the estimates are kept apart, and how small interfaces let you swap one algorithm for another. The architecture and roadmap explain the design, which the code is moving toward step by step (see the roadmap issue).

Requirements

Please satisfy with the following requirements on native or VM Linux in advance.
For running each sample codes:

• Python 3.13.x
• Matplotlib
• NumPy
• SciPy
• CasADi (for MPC path tracking)
• do-mpc (for MPC path tracking)

For development:

• pytest (for unit tests)

For setting up the environment with Docker (see Quick Start):

• Docker
• VS Code with the Dev Containers extension (only for option A)

Quick Start

1. Clone this repository

$ git clone https://github.com/ShisatoYano/AutonomousVehicleControlBeginnersGuide
$ cd AutonomousVehicleControlBeginnersGuide

2. Set up the environment

Choose one of the following options.

Note for options A and B: The container shows the animations through your host's X11 display.

• Linux: Allow local connections to your X server before starting the container. This setting is reset when you log out, so run it again after logging in (or run it automatically at login).

  $ xhost +local:
  

  This allows any local process on your machine to connect to your X server, so be careful on a shared machine.
• Windows / macOS: You need an X server that the container can connect to, such as WSLg on WSL2 or XQuartz on macOS.

A. VS Code + Docker (Dev Container)

1. Install Docker and VS Code with the Dev Containers extension
2. Open this repository's folder in VS Code
3. Run Dev Containers: Reopen in Container from the Command Palette
4. All required libraries are installed automatically. Run the commands in the following steps in VS Code's terminal

B. Docker only

1. Install Docker
2. Build and start the container, and then open a shell in it

   $ docker compose up -d --build
   $ docker compose exec simulation bash
   

3. Run the commands in the following steps in this shell. To stop the container, run docker compose down on your host

C. Local (without Docker)

1. Install Python 3.13.x
2. Create a virtual environment and install the required libraries
   • Linux / macOS:

     $ python3 -m venv .venv
     $ source .venv/bin/activate
     $ pip install -r requirements.txt
     

   • Windows (PowerShell):

     > python -m venv .venv
     > .venv\Scripts\Activate.ps1
     > pip install -r requirements.txt
     

This is the beginning of the README. Read the rest at the original. Read the full README ↗