Imported upstream version '1.16.0' of 'upstream'

.github/workflows/main.yml

@@ -7,15 +7,11 @@ on: [push, pull_request]
 jobs:
   industrial_ci:
     strategy:
-      fail-fast: false
       matrix:
         env:
-          # - {ROS_DISTRO: foxy, ROS_REPO: testing}
-          - {ROS_DISTRO: foxy, ROS_REPO: main}
-          # - {ROS_DISTRO: galactic, ROS_REPO: testing}
-          - {ROS_DISTRO: galactic, ROS_REPO: main}
-          - {ROS_DISTRO: humble, ROS_REPO: main}
-          - {ROS_DISTRO: rolling, ROS_REPO: testing}
+          # - {ROS_DISTRO: melodic, ROS_REPO: testing}
+          - {ROS_DISTRO: melodic, ROS_REPO: main}
+          - {ROS_DISTRO: noetic, ROS_REPO: main}
     env:
       CCACHE_DIR: /github/home/.ccache
       AFTER_INSTALL_TARGET_DEPENDENCIES: ./mavros/scripts/install_geographiclib_datasets.sh

.ycm_extra_conf.py

@@ -0,0 +1,263 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################
+# YouCompleteMe configuration for ROS                                    #
+# Author: Gaël Ecorchard (2015)                                          #
+#                                                                        #
+# The file requires the definition of the $ROS_WORKSPACE variable in     #
+# your shell.                                                            #
+# Name this file .ycm_extra_conf.py and place it in $ROS_WORKSPACE to    #
+# use it.                                                                #
+#                                                                        #
+# Tested with Ubuntu 14.04 and Indigo.                                   #
+#                                                                        #
+# License: CC0                                                           #
+##########################################################################
+
+import os
+import ycm_core
+
+
+def GetRosIncludePaths():
+    """Return a list of potential include directories
+
+    The directories are looked for in $ROS_WORKSPACE.
+    """
+    try:
+        from rospkg import RosPack
+    except ImportError:
+        return []
+    rospack = RosPack()
+    includes = []
+    includes.append(os.path.expandvars('$ROS_WORKSPACE') + '/devel/include')
+    for p in rospack.list():
+        if os.path.exists(rospack.get_path(p) + '/include'):
+            includes.append(rospack.get_path(p) + '/include')
+
+    for distribution in os.listdir('/opt/ros'):
+        includes.append('/opt/ros/' + distribution + '/include')
+
+    return includes
+
+
+def GetRosIncludeFlags():
+    includes = GetRosIncludePaths()
+    flags = []
+    for include in includes:
+        flags.append('-isystem')
+        flags.append(include)
+
+    return flags
+
+# These are the compilation flags that will be used in case there's no
+# compilation database set (by default, one is not set).
+# CHANGE THIS LIST OF FLAGS. YES, THIS IS THE DROID YOU HAVE BEEN LOOKING FOR.
+# You can get CMake to generate the compilation_commands.json file for you by
+# adding:
+#   set(CMAKE_EXPORT_COMPILE_COMMANDS 1)
+# to your CMakeLists.txt file or by once entering
+#   catkin config --cmake-args '-DCMAKE_EXPORT_COMPILE_COMMANDS=ON'
+# in your shell.
+
+default_flags = [
+    '-Wall',
+    '-Wextra',
+    '-Werror',
+    # '-Wc++98-compat',
+    # '-Wno-long-long',
+    # '-Wno-variadic-macros',
+    '-fexceptions',
+    '-DNDEBUG',
+    # THIS IS IMPORTANT! Without a "-std=<something>" flag, clang won't know
+    # which language to use when compiling headers. So it will guess. Badly. So
+    # C++ headers will be compiled as C headers. You don't want that so ALWAYS
+    # specify a "-std=<something>".
+    # For a C project, you would set this to something like 'c99' instead of
+    # 'c++11'.
+    # '-std=c++03',
+    '-std=c++11',
+    # ...and the same thing goes for the magic -x option which specifies the
+    # language that the files to be compiled are written in. This is mostly
+    # relevant for c++ headers.
+    # For a C project, you would set this to 'c' instead of 'c++'.
+    '-x',
+    'c++',
+    '-I',
+    '.',
+
+    # include third party libraries
+    # '-isystem',
+    # '/some/path/include',
+    '-isystem',
+    '/usr/include/eigen3',
+
+    # mavros flags
+    #'-DMAVLINK_DIALECT=ardupilotmega',
+]
+
+flags = default_flags + GetRosIncludeFlags()
+
+
+def GetCompilationDatabaseFolder(filename):
+    """Return the directory potentially containing compilation_commands.json
+
+    Return the absolute path to the folder (NOT the file!) containing the
+    compile_commands.json file to use that instead of 'flags'. See here for
+    more details: http://clang.llvm.org/docs/JSONCompilationDatabase.html.
+    The compilation_commands.json for the given file is returned by getting
+    the package the file belongs to.
+    """
+    try:
+        import rospkg
+    except ImportError:
+        return ''
+    pkg_name = rospkg.get_package_name(filename)
+    if not pkg_name:
+        return ''
+    dir = (os.path.expandvars('$ROS_WORKSPACE') +
+           os.path.sep +
+           'build' +
+           os.path.sep +
+           pkg_name)
+
+    return dir
+
+
+def GetDatabase(compilation_database_folder):
+    if os.path.exists(compilation_database_folder):
+        return ycm_core.CompilationDatabase(compilation_database_folder)
+    return None
+
+SOURCE_EXTENSIONS = ['.cpp', '.cxx', '.cc', '.c', '.m', '.mm']
+
+
+def DirectoryOfThisScript():
+    return os.path.dirname(os.path.abspath(__file__))
+
+
+def MakeRelativePathsInFlagsAbsolute(flags, working_directory):
+    if not working_directory:
+        return list(flags)
+    new_flags = []
+    make_next_absolute = False
+    path_flags = ['-isystem', '-I', '-iquote', '--sysroot=']
+    for flag in flags:
+        new_flag = flag
+
+        if make_next_absolute:
+            make_next_absolute = False
+            if not flag.startswith('/'):
+                new_flag = os.path.join(working_directory, flag)
+
+        for path_flag in path_flags:
+            if flag == path_flag:
+                make_next_absolute = True
+                break
+
+            if flag.startswith(path_flag):
+                path = flag[len(path_flag):]
+                new_flag = path_flag + os.path.join(working_directory, path)
+                break
+
+        if new_flag:
+            new_flags.append(new_flag)
+
+    return new_flags
+
+
+def IsHeaderFile(filename):
+    extension = os.path.splitext(filename)[1]
+    return extension in ['.h', '.hxx', '.hpp', '.hh']
+
+
+def GetCompilationInfoForHeaderSameDir(headerfile, database):
+    """Return compile flags for src file with same base in the same directory
+    """
+    filename_no_ext = os.path.splitext(headerfile)[0]
+    for extension in SOURCE_EXTENSIONS:
+        replacement_file = filename_no_ext + extension
+        if os.path.exists(replacement_file):
+            compilation_info = database.GetCompilationInfoForFile(
+                replacement_file)
+            if compilation_info.compiler_flags_:
+                return compilation_info
+    return None
+
+
+def GetCompilationInfoForHeaderRos(headerfile, database):
+    """Return the compile flags for the corresponding src file in ROS
+
+    Return the compile flags for the source file corresponding to the header
+    file in the ROS where the header file is.
+    """
+    try:
+        import rospkg
+    except ImportError:
+        return None
+    pkg_name = rospkg.get_package_name(headerfile)
+    if not pkg_name:
+        return None
+    try:
+        pkg_path = rospkg.RosPack().get_path(pkg_name)
+    except rospkg.ResourceNotFound:
+        return None
+    filename_no_ext = os.path.splitext(headerfile)[0]
+    hdr_basename_no_ext = os.path.basename(filename_no_ext)
+    for path, dirs, files in os.walk(pkg_path):
+        for src_filename in files:
+            src_basename_no_ext = os.path.splitext(src_filename)[0]
+            if hdr_basename_no_ext != src_basename_no_ext:
+                continue
+            for extension in SOURCE_EXTENSIONS:
+                if src_filename.endswith(extension):
+                    compilation_info = database.GetCompilationInfoForFile(
+                        path + os.path.sep + src_filename)
+                    if compilation_info.compiler_flags_:
+                        return compilation_info
+    return None
+
+
+def GetCompilationInfoForFile(filename, database):
+    # The compilation_commands.json file generated by CMake does not have
+    # entries for header files. So we do our best by asking the db for flags
+    # for a corresponding source file, if any. If one exists, the flags for
+    # that file should be good enough.
+    # Corresponding source file are looked for in the same package.
+    if IsHeaderFile(filename):
+        # Look in the same directory.
+        compilation_info = GetCompilationInfoForHeaderSameDir(
+            filename, database)
+        if compilation_info:
+            return compilation_info
+        # Look in the package.
+        compilation_info = GetCompilationInfoForHeaderRos(filename, database)
+        if compilation_info:
+            return compilation_info
+    return database.GetCompilationInfoForFile(filename)
+
+
+def FlagsForFile(filename):
+    database = GetDatabase(GetCompilationDatabaseFolder(filename))
+    if database:
+        # Bear in mind that compilation_info.compiler_flags_ does NOT return a
+        # python list, but a "list-like" StringVec object
+        compilation_info = GetCompilationInfoForFile(filename, database)
+        if not compilation_info:
+            # Return the default flags defined above.
+            return {
+                'flags': flags,
+                'do_cache': True,
+            }
+
+        final_flags = MakeRelativePathsInFlagsAbsolute(
+            compilation_info.compiler_flags_,
+            compilation_info.compiler_working_dir_)
+        final_flags += default_flags
+    else:
+        relative_to = DirectoryOfThisScript()
+        final_flags = MakeRelativePathsInFlagsAbsolute(flags, relative_to)
+
+    return {
+        'flags': final_flags,
+        'do_cache': True
+    }

CONTRIBUTING.md

@@ -1,76 +1,46 @@
-# Contributing
-
-1. Fork the repo. [<img src="https://upload.wikimedia.org/wikipedia/commons/3/38/GitHub_Fork_Button.png" height="30"/>](https://github.com/mavlink/mavros/fork)
-2. Clone the repo into your workspace:
-
-  ```bash
-  git clone https://github.com/mavlink/mavros.git
-  ```
-
-3. Create a remote connection to your repo:
-
-  ```bash
-  git remote add origin [email protected]:<YourGitUser>/mavros.git
-  ```
-
-4. Create a feature/dev branch:
-
-  ```bash
-  git checkout -b <feature_branch>
-  ```
-
-5. Make your changes.
-6. Commit the changes. The `-a` option automatically adds and removes files for you.
-
-  ```bash
-  git commit -a -m "<message>"
-  ```
-
-7. Check your code style:
-
-  ```bash
-  uncrustify -c ${ROS_WORKSPACE}/src/mavros/mavros/tools/uncrustify-cpp.cfg --replace --no-backup <path/to/file.ext>
-  ```
-
-8. Fix small code style errors and typos.
-9. Commit with a description like "uncrustify" or "code style fix". Please avoid changes in program logic (separate commits are better than a mix of style and bug fixes).
+Contributing
+============
+
+
+1. Fork the repo:
+   ![fork](http://s24.postimg.org/pfvt9sdv9/Fork_mavros.png)
+2. Clone the repo (`git clone https://github.com/mavlink/mavros.git`);
+3. Create a remote connection to your repo (`git remote add <remote_repo> [email protected]:<YourGitUser>/mavros.git`);
+4. Create a feature/dev branch (`git checkout -b <feature_branch>`);
+5. Add the changes;
+6. Apply the changes by committing (`git commit -m "<message>"` or `git commit -a` and then write message; if adding new files: `git add <path/to/file.ext>`);
+7. Check code style `uncrustify -c ${ROS_WORKSPACE}/src/mavros/mavros/tools/uncrustify-cpp.cfg --replace --no-backup <path/to/file.ext>`;
+8. Fix small code style errors and typos;
+9. Commit with description like "uncrustify" or "code style fix". Please avoid changes in program logic (separate commit are better than mix of style and bug fix);
 10. Run tests:
+   - with `catkin_make`, issue `catkin_make tests` and then `catkin_make run_tests`;
+   - with `catkin tools`, issue `catkin run_tests`;
+11. If everything goes as planned, push the changes (`git push -u <remote_repo> <feature_branch>`) and issue a pull request.
 
-- with `catkin_make`, issue `catkin_make tests` and then `catkin_make run_tests`;
-- with `catkin tools`, issue `catkin run_tests`;
-
-11. If everything goes as planned, push the changes and issue a pull request.
 
-```bash
-git push -u origin <feature_branch>
-```
+cog.py generators
+-----------------
 
-## cog.py generators
+In many places we need to copy some data from MAVLink, and in many places we have regular patterns of code (e.g. copy message fields).
+To avoid manual copy-paste work (and errors!) we use [cog.py][cog] generator/preprocessor.
+Generator program written in comment blocks on Python (that allow import pymavlink), output will be inserted between markers.
+As an example you may look at `utils::to_string()` implementation for some enums: [lib/enum_to_string.cpp][ets].
 
-In many places we need to copy some data from MAVLink, and in many places we have regular patterns of code (e.g. copied message fields).
-To avoid manual copy-paste work (and errors!) we use the the [cog.py][cog] code generator/preprocessor.
+To install it :
 
-Cog generates C++ code from code blocks written in Python that you add into your C++ code file as specially formatted comments. Since you are now using Python, you can import and make use of the [pymavlink][pml] module, which already comes with MAVlink message definitions that you can reuse.
-An example you may look at is the `utils::to_string()` implementation for some enums in [lib/enum_to_string.cpp][ets].
+    pip install --user cogapp pymavlink
 
-Install cog and pymavlink:
+Then fill the behaviour you when between the `[[[cog:]]]` `[[[end]]]` balise
+and invoke cog like this:
 
-```bash
-pip install --user cogapp pymavlink
-```
+    cog.py -cr your_file.h/cpp
 
-Add your generator code to your file as comments enclosed in the `[[[cog:]]]` and `[[[end]]]` tags. Then invoke cog so that it updates your file:
+Your file will be updated by cog.
 
-```bash
-cog.py -cr your_file.h/cpp
-```
+    ./mavros/tools/cogall.sh
 
-In addition, this script will re-generate all files with cog code:
+This script will regenerate all files with generators.
 
-```bash
-./mavros/tools/cogall.sh
-```
 
 [cog]: https://nedbatchelder.com/code/cog/
 [ets]: https://github.com/mavlink/mavros/blob/master/mavros/src/lib/enum_to_string.cpp
-[pml]: https://mavlink.io/en/mavgen_python/