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/