Before starting these tutorials please complete installation

configuring ROS Environment:

If you are ever having problems finding or using your ROS packages make sure that you have your environment properly setup. A good way to check is to ensure that environment variables like ROS_ROOT and ROS_PACKAGE_PATH are set :

printenv | grep ROS

If they are not then you might need to 'source' some setup.*sh files.

If you just installed ROS from apt on Ubuntu then you will have setup.*sh files in '/opt/ros/<distro>/', and you could source them like so:

$ source /opt/ros/<distro>/setup.bash

Using the short name of your ROS distribution instead of <distro>

If you installed ROS Melodic, that would be:

source /opt/ros/melodic/setup.bash

You will need to run this command on every new shell you open to have access to the ROS commands, unless you add this line to your .bashrc.

Create a ROS Workspace

mkdir -p ~/catkin_ws/src
cd ~/catkin_ws/
catkin_make

but when you run catkin_make command then you may get error

ImportError: "from catkin_pkg.package import parse_package" failed: No module named 'catkin_pkg'
Make sure that you have installed "catkin_pkg", it is up to date and on the PYTHONPATH.
CMake Error at /opt/ros/melodic/share/catkin/cmake/safe_execute_process.cmake:11 (message):
  execute_process(/usr/bin/python3
  "/opt/ros/melodic/share/catkin/cmake/parse_package_xml.py"
  "/opt/ros/melodic/share/catkin/cmake/../package.xml"
  "/home/vboxuser/catkin_ws/build/catkin/catkin_generated/version/package.cmake")
  returned error code 1
Call Stack (most recent call first):
  /opt/ros/melodic/share/catkin/cmake/catkin_package_xml.cmake:74 (safe_execute_process)
  /opt/ros/melodic/share/catkin/cmake/all.cmake:168 (_catkin_package_xml)
  /opt/ros/melodic/share/catkin/cmake/catkinConfig.cmake:20 (include)
  CMakeLists.txt:58 (find_package)


-- Configuring incomplete, errors occurred!
See also "/home/vboxuser/catkin_ws/build/CMakeFiles/CMakeOutput.log".
See also "/home/vboxuser/catkin_ws/build/CMakeFiles/CMakeError.log".
Makefile:320: recipe for target 'cmake_check_build_system' failed
make: *** [cmake_check_build_system] Error 1
Invoking "make cmake_check_build_system" failed

To resolve this error we have to install some package which are:

sudo apt-get install python3-catkin-pkg-modules

After installing catkin_pkg, try running catkin_make again in your catkin_ws:

cd ~/catkin_ws
catkin_make

The catkin_make command is a convenience tool for working with catkin workspaces. Running it the first time in your workspace, it will create a CMakeLists.txt link in your 'src' folder.

Python 3 users in ROS Melodic and earlier: note, if you are building ROS from source to achieve Python 3 compatibility, and have setup your system appropriately (ie: have the Python 3 versions of all the required ROS Python packages installed, such as catkin) the first catkin_make command in a clean catkin_workspace must be:

catkin_make -DPYTHON_EXECUTABLE=/usr/bin/python3

This will configure catkin_make in python 3. You may then proceed to use just catkin_make for subsequent builds.

Additionally, if you look in your current directory you should now have a 'build' and 'devel' folder. Inside the 'devel' folder you can see that there are now several setup.*sh files. Sourcing any of these files will overlay this workspace on top of your environment.

To make sure your workspace is properly overlayed by the setup script, make sure ROS_PACKAGE_PATH environment variable includes the directory you're in.

echo $ROS_PACKAGE_PATH

Navigating the ROS Filesystem

Code is spread across many ROS packages. Navigating with command-line tools such as ls and cd can be very tedious which is why ROS provides tools to help you.

Using rospack

rospack allows you to get information about packages. In this tutorial, we are only going to cover the find option, which returns the path to package.

rospack find [package_name]

#example
rospack find roscpp

Using roscd

roscd is a part of the rosbash suite. It allows you to change directory (cd) directly to a package or a stack.

roscd <package-or-stack>[/subdir]

roscd roscpp

Subdirectories

roscd can also move to a subdirectory of a package or stack.

roscd roscpp/cmake
pwd

roscd log

roscd log will take you to the folder where ROS stores log files. Note that if you have not run any ROS programs yet, this will yield an error saying that it does not yet exist.

If you have run some ROS program before, try:

roscd log

Using rosls

rosls is a part of the rosbash suite. It allows you to ls directly in a package by name rather than by absolute path.

Usage:

rosls roscpp_tutorials

Tab Completion

It can get tedious to type out an entire package name. In the previous example, roscpp_tutorials is a fairly long name. Luckily, some ROS tools support TAB COMPLETION.

After pushing the TAB key, the command line should fill out the rest.

You may have noticed a pattern with the naming of the ROS tools:

• rospack = ros + package

• roscd = ros + cd

• rosls = ros + ls

Creating a ROS Package

catkin package contains package.xml file, CMakeLists.txt and also Each package must have its own folder

•     my_package/
        CMakeLists.txt
        package.xml
  

Packages in a catkin Workspace

workspace_folder/        -- WORKSPACE
  src/                   -- SOURCE SPACE
    CMakeLists.txt       -- 'Toplevel' CMake file, provided by catkin
    package_1/
      CMakeLists.txt     -- CMakeLists.txt file for package_1
      package.xml        -- Package manifest for package_1
    ...
    package_n/
      CMakeLists.txt     -- CMakeLists.txt file for package_n
      package.xml        -- Package manifest for package_n

Creating a catkin Package

first create the catkin workspace and move into it

cd ~/catkin_ws/src

Now use the catkin_create_pkg script to create a new package called 'beginner_tutorials' which depends on std_msgs, roscpp, and rospy:

catkin_create_pkg beginner_tutorials std_msgs rospy roscpp

This will create a beginner_tutorials folder which contains a package.xml and a CMakeLists.txt, which have been partially filled out with the information you gave catkin_create_pkg.

catkin_create_pkg requires that you give it a package_name and optionally a list of dependencies on which that package depends:

# This is an example, do not try to run this
# catkin_create_pkg <package_name> [depend1] [depend2] [depend3]

Building a catkin workspace and sourcing the setup file

cd ~/catkin_ws
catkin_make

After the workspace has been built it has created a similar structure in the devel subfolder as you usually find under /opt/ros/$ROSDISTRO_NAME.

To add the workspace to your ROS environment you need to source the generated setup file:

. ~/catkin_ws/devel/setup.bash

package dependencies

1 First-order dependencies :

When using catkin_create_pkg earlier, a few package dependencies were provided. These first-order dependencies can now be reviewed with the rospack tool.

rospack depends1 beginner_tutorials

As you can see, rospack lists the same dependencies that were used as arguments when running catkin_create_pkg. These dependencies for a package are stored in the package.xml file:

roscd beginner_tutorials
cat package.xml

2 Indirect dependencies

In many cases, a dependency will also have its own dependencies. For instance, rospy has other dependencies.

 rospack depends1 rospy

A package can have quite a few indirect dependencies. Luckily rospack can recursively determine all nested dependencies.

rospack depends beginner_tutorials

Customizing Your Package

This part of the tutorial will look at each file generated by catkin_create_pkg and describe, line by line, each component of those files and how you can customize them for your package.

Customizing the package.xml

First update the description tag:

Change the description to anything you like, but by convention the first sentence should be short while covering the scope of the package. If it is hard to describe the package in a single sentence then it might need to be broken up.

vim package.xml

Maintainer tags : we have to do the changes in the package.xml file

 <maintainer email="you@yourdomain.tld">Your Name</maintainer>

This is a required and important tag for the package.xml because it lets others know who to contact about the package.

license tags

You should choose a license and fill it in here. Some common open source licenses are BSD, MIT, Boost Software License, GPLv2, GPLv3, LGPLv2.1, and LGPLv3.

dependencies tags

All of our listed dependencies have been added as a build_depend for us, in addition to the default buildtool_depend on catkin. In this case we want all of our specified dependencies to be available at build and run time, so we'll add a exec_depend tag for each of them as well.

lets build our package

Building Packages

As long as all of the system dependencies of your package are installed, we can now build your new package.

I hope you guys enjoys the blog do share and like it

want to connect with me 👇👇👇

My Contact Info:

📩Email:-mayank07082001@gmail.com

LinkedIn:-linkedin.com/in/mayank-sharma-devops