Coder Social home page Coder Social logo

engahmed53 / roboticsnd-home-service-robot Goto Github PK

View Code? Open in Web Editor NEW
0.0 1.0 0.0 4.51 MB

Robotics Software Engineer Nanodegree Final Project

License: MIT License

CMake 51.08% C++ 20.53% Shell 7.33% Python 21.06%
cpp gazebo localization monte-carlo-localization robotics ros rviz slam-gmapping solidworks path-planning

roboticsnd-home-service-robot's Introduction

RoboticsND-Home-Service-Robot

Final project for Udacity's Robotics Software Engineer Nanodegree.

A Home Service Robot simulated in ROS and Gazebo. The service-robot performs SLAM to map an indoor environment, localizes itself and autonomously navigates to pick up and place objects around the house. The aim is to navigate to a pick-up location to collect a virtual object and then navigate to a specified drop-off zone to deposit it.

Home Service Robot
Home Service Robot Demo

Project info

A custom differential drive robot designed using solidworks is used.

Custom Robot
My Robot

The project consists of the following parts:

  • Design an indoor environment with the Building Editor in Gazebo.
  • Create a 2D occupancy grid map of the environment by teleoperating the robot and performing SLAM using the gmapping package (utilizing odometry and laser scan data).
  • Use Adaptive Monte Carlo Localization (AMCL) to localize the robot inside the environment with the amcl package (by utilizing odometry and laser scan data).
  • Test the navigation stack and send a goal for the robot to navigate to via the 2D Nav Goal button in Rviz.
  • Write a pick_objects node that commands the robot to navigate to the desired pick-up and drop-off zones.
  • Write an add_markers node that subscribes to the robot odometry and publishes markers to Rviz to simulate the object pick-up and drop-off.

The home environment
The Home Environment

Structure

There are three packages in this project:

  • my_robot: This package holds the Gazebo world, the amcl parameters, the rviz configurations, the generated map, the launch files to interface with all the packages and scripts to automatically run them.
  • pick_objects: This package is responsible for commanding the robot to navigate to the desired pick-up and drop-off locations.
  • add_markers: This package publishes markers to rviz to simulate the object pick-up and drop-off.
  • teleop_twist_keyboard: This package is used to teleoperate the robot.
  • AMCL: The AMCL (Adaptive Monte Carlo Localization) ROS package has been employed for localization tasks. AMCL is a probabilistic localization algorithm that utilizes a particle filter to estimate the robot's pose within a known map. It integrates sensor measurements with a motion model to adaptively adjust the particle distribution, providing accurate and robust localization even in dynamic environments. By leveraging AMCL, the robot is capable of determining its position and orientation relative to a given map with a high degree of precision.
  • Mapping: For mapping the environment, the project relies on the GMapping (Grid-based FastSLAM) ROS package. GMapping is an efficient implementation of the FastSLAM algorithm, which combines laser scan measurements and odometry data to create a 2D occupancy grid map. This map represents the robot's perception of the surrounding environment, highlighting areas that are occupied, free, or unknown. GMapping allows the robot to build and update a map in real-time, enabling it to navigate effectively through various environments while avoiding obstacles.
  • Navigation: The ROS Navigation Stack is utilized for navigation tasks in the project. This comprehensive package provides a modular and configurable framework for autonomous robot navigation. It incorporates various components such as path planning, obstacle avoidance, and trajectory execution. The navigation stack utilizes the information from the localization and mapping modules to plan a feasible path for the robot, considering the dynamic aspects of the environment. By combining AMCL for localization, GMapping for mapping, and the ROS Navigation Stack for path planning, the robot can autonomously navigate through complex environments while avoiding obstacles and reaching its destination.

The directory structure is depicted below:

. RoboticsND-Home-Service-Robot
├── LICENSE
├── README.md
├── add_markers                         # Publishes markers to Rviz to simulate the object pick-up and drop-off
│   ├── CMakeLists.txt
│   ├── package.xml
│   └── src
│       └── add_markers.cpp
├── my_robot
│   ├── CMakeLists.txt
│   ├── config                          # amcl parameters
│   │   ├── base_local_planner_params.yaml
│   │   ├── costmap_common_params.yaml
│   │   ├── global_costmap_params.yaml
│   │   ├── local_costmap_params.yaml
│   │   └── joint_names_my_robot.yaml # robot joint names
│   ├── launch
│   │   ├── amcl.launch            # Launches the amcl package for localization
│   │   ├── gmapping_demo.launch        # Launches the gmapping package for performing SLAM & creating a 2D map
│   │   ├── robot_description.launch    # Launches the robot
│   │   ├── view_navigation.launch      # Launches Rviz with saved config
│   │   └── world.launch                # Launches the home environment 
│   ├── map                             # The map of the environment
│   │   ├── home_service_map.pgm
│   │   └── home_service_map.yaml
│   ├── meshes                           # Robot link meshes
│   │   ├── base_link.STL
│   │   ├── leftwheel.STL
│   │   ├── rightwheel.STL
│   │   └── hokuyo.dae
│   ├── package.xml
│   ├── rviz
│   │   └── rviz.rviz
│   ├── scripts
│   │   ├── add_markers.sh
│   │   ├── home_service.sh             # To run the home service robot
│   │   ├── pick_objects.sh
│   │   ├── test_navigation.sh
│   │   └── test_slam.sh
├── urdf                                # Robot URDF files
│   │   ├── my_robot.csv
│   │   ├── my_robot.gazebo
│   │   ├── my_robot.xacro
│   └── worlds
│       └── home_v_2.world
├── images                              # Simulation images
│   ├── home.png
│   ├── home_service.gif
│   ├── home_service_map.png
│   └── rviz.png
└── pick_objects                        # Commands the robot to navigate to the desired pick-up and drop-off zones
    ├── CMakeLists.txt
    ├── package.xml
    └── src
        └── pick_objects.cpp

Technologies

The project was developed on Ubuntu 20.04 LTS with:

  • ROS Noetic
  • Gazebo 11.11.0

Dependencies

The following dependencies need to be installed:

$ sudo apt-get update && sudo apt-get upgrade -y
$ sudo apt-get install ros-noetic-teleop-twist-keyboard
$ sudo apt-get install ros-noetic-openslam-gmapping
$ sudo apt-get install ros-noetic-navigation

The scripts to run multiple packages utilize the xterm terminal which can be installed via:

$ sudo apt-get install xterm

Installation

To run this project, you must have ROS and Gazebo installed.

1. Create a catkin_ws, if you do not already have one.

$ mkdir -p /catkin_ws/src/
$ cd catkin_ws/src/
$ catkin_init_workspace

2. Clone the project in catkin_ws/src/ and move its contents to src/.

$ git clon https://github.com/EngAhmed53/RoboticsND-Home-Service-Robot.git
$ sudo mv RoboticsND-Home-Service-Robot/* ./

3. Build the packages.

$ cd /catkin_ws/
$ catkin_make

4. Source your environment.

$ source devel/setup.bash

5. Make the scripts executable.

$ cd src/home_service/scripts
$ sudo chmod +x *.sh

Part 1: SLAM

Optional: If you would like to test the SLAM algorithm and create a new map of the environment, run:

$ ./test_slam.sh

Teleoperate the robot through your keyboard to explore the environment and see the map appear in Rviz. Once the house is fully explored, save the map with:

$ rosrun map_server map_saver -f ../map/home_service_map

Part 2: Navigation

Optional: If you would like to test the navigation algorithm, run:

$ ./test_navigation.sh

Now you will be using the already generated map and localize with AMCL. Press the 2D Nav Goal button in Rviz and click somewhere on the map to command the robot to navigate there.

Navigation
Navigation

Part 3: Home Service

To simulate the full home service robot, run:

$ ./home_service.sh

The robot will be using the generated map and will localize itself with the acml package. It will navigate to a virtual object (indicated by a green cube in Rviz), pick-up the object (the cube will disappear to simulate the pick-up) and then the robot will navigate to a drop-off zone and deliver the object (the cube will re-appear once the robot reaches the drop-off location).


roboticsnd-home-service-robot's People

Contributors

engahmed53 avatar

Watchers

 avatar

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.