Lab 7: Collision Avoidance

Overview

In this lab, we will focus on robot navigation in an environment with moving obstacles. We will implement two different approaches:

Reactive Distance-Based Forces (DBF): In this method, the robot computes a repulsive force from each nearby obstacle based on the current distance. The force increases as the obstacle gets closer, pushing the robot away to avoid collisions.

Predictive Time-to-Collision Forces (TTCF): This approach estimates the time-to-collision (τ) with each obstacle. If a collision is predicted within a given time horizon, a repulsive force is generated that scales inversely with τ, allowing the robot to predict and avoid imminent collisions.

Both methods are used to compute forces that drive the robot toward its goal while simultaneously avoiding obstacles. The computed forces are combined and integrated to update the robot’s velocity. Finally, a proportional controller (P-controller) should be used to convert the resulting velocity into motion commands (linear and angular speeds).

Submission

Submission: group submission via Gradescope.
Demo: in person demo not required, but you need to submit your video demos.
Due time: 11:59pm, March 11, Tuesday
Files to submit:
- lab7_report.pdf
  - Include the 2D and 3D plots from the visualization.
  - Submit a link to your videos in the report. Make sure your link is working and anyone with the link can see it!
  - Follow the format below when recording the videos for the two different scenarios using the two different methods.
  - In total there should be 4 videos.
  - Mention the parameters you used to tune each scenario.
- robot_move_distance.py
- robot_move_ttc.py
Grading rubric:
- + 20% Clearly describe your approach, explain your code, and the differences between the two methods in the lab report and video
- + 20% Reach the goal without collisions using DBF for environment 1
- + 20% Reach the goal within 30s and without collision using TTCF for environment 1
- + 20% Reach the goal without collisions using DBF for environment 2
- + 20% Reach the goal within 40s and without collisions using TTCF for environment 2
- - 10% Penalty applies for each late day. No submission will be accepted beyond two (2) days from the due date
Note: When using Scenario 2, make sure to Subscribe to the topics of the extra obstacles and visualize.

Follow this format when recording the video.

Use top view and have the terminal on the bottom left of the screen.

Setting up the environment

Download the collision_plugin.zip, lab7.zip from using these links inside your VM, and follow the steps to create the environment.
First, copy and unzip collision_plugin.zip to ~/catkin_ws/src and follow these steps.

cd ~/catkin_ws/

catkin_make

Then, copy and unzip lab7.zip to ~/catkin_ws/src/ee144w25/src.
Go to Lab7 folder.
Open obs_env_moving_s1.world and obs_env_moving_s2.world in Lab7 folder using your editor and replace [Home directory] with the name of you home directory. You can get it by following these steps.

cd ~

pwd

collision_env.launch file launches the environment and runs the [Agent] that you use for collision avoidance. You can comment/uncomment the agent/environment you use/unuse.
move_cylinder_s1/2.py create the dynamic obstacle environment.
visualization.py file generate 2d and 3d plot for the path the robot and obstacles visited.
robot_move_distance.py file is a template for the DBAgent.
robot_move_ttc.py file is a template for the TTCAgent.
For this lab, you need to complete the DBAgent and the TTCAgent and test it using the provided environments.
Start with S1 environment.
Use the following command to run the lab.

roslaunch ee144w25 collision_env.launch

DBAgent & TTCAgent:

At each local planning step, you need to compute a collection of forces to determine the behavior of the robot and update the robot’s velocity. To do so, modify the computeForces function in order to :

1. Determine the goal (driving) force of the agent as explained in class, i.e.:

Here, we assume that the goal velocity, vg, is the unit vector pointing from the current position of the agent to its goal position scaled by the agent’s goal preferred speed. A typical value for ξ is 0.5s. The constant m denotes the mass of the agent. You can assume a unit mass.

2. Determine all obstacles that are less than dH away from the agent. A typical value for dH is 5.

3. Calculate a repulsive force between the agent and each obstacle.

The Distance-Based Forces model is a reactive approach, with each obstacle applying a distance-dependent repulsive force to the robot. You should refer to lectures 21 & 22, but the force should be of the form:

where d denotes the body-body distance between the obstacle O and the robot A, and n denotes the unit vector that points from the obstacle’s current position to the robot’s position.

The TTC Forces model is a predictive approach, with each obstacle exerting a force to the robot based on their predicted time-to-collision value, τ. To determine τ you need to implement the compute_ttc function as explained in lecture 22. If there is a predicted collision, add the corresponding repulsive force to Fg. You should refer to lectures 22 & 23, but the force should be of the form:

where nτ denotes the unit vector that pushes the two agents apart at the moment of their impact. Typical value for the time horizon τH is 3s.

4. Add all forces (goal force and obstacle repulsive forces) to determine the final force F acting on the robot. Update the velocity of the robot based on the computed F by using simple Euler integration, where the time step ∆t is set to be equal to the controller’s update rate. You may also want to cap the maximum amount of force that is applied to the agent before computing the new velocity.