Warmup Project

Objectives

Your goal in this project is to get comfortable programming the Turtlebot3 robot in the Gazebo simulator. You'll be asked to program the robot to perform one or more behaviors. Additionally, in the process, you'll learn about tools and strategies for debugging robot programs. If you have any questions about this project or find yourself getting stuck, please post on the course Slack or send a Slack DM to the teaching team. Even if you don't find yourself hitting roadblocks, feel free to share with your peers what's working well for you.

Learning Goals

Get comfortable with ROS
Brush up on your Python programming
Learn about processing sensor data from the robot
Learn about programming robot behaviors
Learn ways to debug robot programs
Learn about reactive robot control

Logistics

This assignment is to be completed individually. You can get help from your fellow classmates setting up your programming environment and completing the ROS beginner tutorials. For the meat of this problem set (programming Turtlebot3 behaviors), you can ask your fellow classmates for general advice or tips on ROS/robot programming, however, the work of programming the robot's behavior must be done by you (no sharing code, no copying code, no looking at other people's code).

Deliverables

You'll submit this project on Github (both the code and the writeup). Fork our starter git repo to get our starter code and so that we can track your project. You'll want to put the warmup_project git repo within your ~/catkin_ws/src/ directory (where ROS packages should be located).

Note: If you're new to Github, please make an account and familiarize yourself with the basics of Github. This is a link to the Hello World Github Guide, which presents the fundamentals of using Github. The free version of Github should be enough for the purposes of this course. However, if you would like, you can get the pro version as a student from here for free.

Code

Please put all of your code in a scripts directory within warmup_project.

When grading your code, we'll be looking for:

Object-oriented programs
Readable variable names
At minimum, light commenting of your code (e.g., one comment per function, one comment per conditional, one comment per loop, ~ 1 comment per 10 lines of code or so)

rosbags

For each of the behaviors you program for your robot, we ask that you record your robot performing that behavior in a rosbag. Please record only the /scan and /cmd_vel ROS topics so that your bagfiles aren't enormous. Please put all of your rosbags in a bags directory within warmup_project with a name that will help us easily identify which behavior you've recorded. For ease of use, here's how to record a rosbag:

$ rosbag record -O filename.bag topic-names

For mor information on rosbags, please refer to the ROS Resources page.

Writeup

Please modify the README.md file as your writeup for this project. Also, feel free to checkout this Mastering Markdown Github Guide page for tips on how to style your README.md. Your writeup should include:

For each robot behavior, please provide the following:
- A high-level description (a few sentences): Describe the problem and your approach at a high-level. Include any relevant diagrams or pictures that help to explain your approach.
- Code explanation (a couple of sentences per function): Describe the structure of your code. For the functions you wrote, describe what each of them does.
- A gif: Record a gif of the robot performing the behavior. Include this gif in your writeup and use it for analysis if needed. For instructions on how to make a gif recording, look at Gazebo simulator.
Challenges (1 paragraph): Describe the challenges you faced programming these robot behaviors and how you overcame them.
Future work (1 paragraph): If you had more time, how would you improve your robot behaviors?
Takeaways (at least 2 bullet points with a few sentences per bullet point): What are your key takeaways from this project that would help you/others in future robot programming assignments? For each takeaway, provide a few sentences of elaboration.

Note: We highly recommend that you do not leave the writeup of this project to the last minute. You will have a much better writeup if you write incrementally, as you progress through the project. Writing up your work as you go may even help you think through your robot programs and improve the implementation and organization of your robot programs.

Here is a list of the files that you are likely to make/edit during this project:

warmup_project/bags/wall_follower_demo.bag
warmup_project/bags/person_follower_demo.bag
warmup_project/scripts/drive_square.py
warmup_project/scripts/wall_follwer.py
warmup_project/scripts/person_follower.py
warmup_project/README.md

Grading

The warmup project will be graded as follows:

30% Writeup
- 8% Driving in a Square Writeup & gif
- 8% Wall Follower Writeup & gif
- 8% Person Follower Writeup & gif
- 6% Challenges, Future Work, Takeaways
6% ROS Bag Recordings
64% Code
- 20% Driving in a Square Code
  - 16% Implementation
  - 2% Object-Oriented Code
  - 2% Code Comments & Readability
- 22% Person Follower Code
  - 18% Implementation
  - 2% Object-Oriented Code
  - 2% Code Comments & Readability
- 22% Wall Follower Code
  - 18% Implementation
  - 2% Object-Oriented Code
  - 2% Code Comments & Readability

Deadlines & Submission

Monday, April 5 11:00am CST - Complete the "driving in a square" robot behavior and writeup. For the writeup, you only need to complete the writeup components that are specific to the "driving in a square" (the first 3 bullets in the "Writeup" section above).
Monday, April 12 11:00am CST - Complete all of the robot behaviors and the writeup.

Submission

We will consider your latest commit before 11:00 AM CST as your submission for each deadline. Do not forget to push your changes to your git repo.

Getting Started

Before you're ready to program your robot, you'll need to take the following steps:

Follow the instructions on the Computer Setup resource page to set up your programming environment and configure your catkin workspace for programming the Turtlebot3 robot.
Check out our guide for using the Gazebo simulator on the Gazebo Simulator resource page on our course website for tips on how to use the simulator.
Read through the ROS Resource page for a quick reference to useful ROS commands, debugging using RViz, and instructions on how to record and use rosbags.
Fork our starter git repo, cloning it within your ~/catkin_ws/src/ directory (where ROS packages should be located).

Running Your Code

In order to run your code for this project, you'll likely have at least 3 terminals running: one running roscore, one used to launch and run the Gazebo simulator, and one running the program you've written to control the robot. Here's an example of what the commands used to run these three tasks may look like.

First terminal: run roscore.

$ roscore

Second terminal: launch and run the Gazebo simulator with a specific world file. For the wall follower, you'll use the turtlebot3_in_room.launch launch file I've provided in the warmup_project ROS package. For the other robot behaviors, you can use the turtlebot3_empty_world.launch launch file in the turtlebot3_gazebo ROS package.

$ roslaunch [package-name] [launch-file-name]

Third terminal: run your program to control the robot. For example, if my robot wall following code is in the `scripts/wall_follower.py` file, my package name is warmup_project and my script name is wall_follwer.py.

$ rosrun [package-name] [name-of-your-script]

Note: You may have to run chmod u+x wall_follower.py (or substitute wall_follower.py for the name of your python script) in order to make your python script executable.

Turtlebot3 Behavior Programming

Driving in a Square

Your goal is to write a ROS node that commands the Turtlebot3 robot to drive a square path. You can accomplish this by using either timing (e.g., move forward for a fixed amount of time then make a 90 degree turn four times) or using Turtlebot3's odometry (check out the /odom topic). You can choose which approach to take, however, we will point out that using timing is significantly easier. The following are good examples of what you can expect your drive in a square behavior to look like:

Tips:

One thing you should notice right away is that there is noise in the environment and in the mapping of your commands to the robot and how it executes them. Your robot will not perfectly execute your commands due to friction, imprecise elements of controlling physical motors, etc.
Your driving in a square does not have to be "perfect". It should roughly drive in a square. If it ends up a few inches away from where it started, that's more than fine.
If you are spending hours on this, hitting mental walls, or feeling frustrated, reach out to the teaching team for help! This is your first time programming a robot, give yourself some slack, and reach out for help. That's what we're here for!

Person Follower

Your goal is to write a script that follows a person (or its closets object) while maintaining a safe distance. In your simulators, you can use a basic shape such as a cylinder as the object your robot should follow and simply move it around in the simulator. We recommend that you use the /scan rostopic, which contains the data from the robot's LiDAR to determine the robot's relative position to what's surrounding it. Pay close attention to how your robot determines where a person is and make sure your robot is facing the supposed person once it gets to the safe distance. The behavior should look somewhat like the following,

Tips:

You'll want to think about how to use the /scan ROS topic.
You'll need your Turtlebot3 to adjust to changes in the "person"'s location (e.g., the person may originally be at location x and the robot is heading towards x, and before the robot reaches x, the person's location may change to y, and the robot will need to immediately adjust its plan)
You'll want to be able to handle a scenario where the "person" is 3 meters directly behind the robot.

Wall Follower

Your goal with this robot behavior is to 1) have your robot navigate close to a wall, 2) drive alongside the wall at an approximately fixed distance, and 3) handle corners. You'll use the turtlebot3_in_room.launch launch file, where the Turtlebot3 is situated in a square room. When working properly, your robot should run around this square room (either clockwise or counterclockwise) indefinitely. Here are some examples of what your wall follower implementation may look like:

Tips:

Your robot should be able to follow walls and round corners in any environment with a wall and shouldn't be specifically programmed to follow walls in the square room provided (if we drop your robot anywhere in this square room, it should be able to find a wall and start following it).
You may find this diagram helpful when thinking about what the goal should be of your robot controller:

Acknowledgments

The design of this course project was influenced by Paul Ruvolo and his Fall 2020 A Computational Introduction to Robotics course taught at Olin College of Engineering. The gifs providing examples of the robot behaviors (drive in a square, person follower, and wall follower) are from the members of the Winter 2021 Introduction to Robotics class, used with permission.