Package Summary

Tags No category tags.
Version 0.0.0
License Apache License 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description Generic and simple controls framework for ROS 2
Checkout URI https://github.com/ros-controls/ros2_control.git
VCS Type git
VCS Version humble
Last Updated 2025-08-07
Dev Status DEVELOPED
Released RELEASED
Tags controllers control robotics ros control-systems robot-control ros2 ros2-control ros2-rolling ros2-humble ros2-jazzy
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Interface for enforcing joint limits.

Additional Links

Maintainers

  • Bence Magyar
  • Denis Štogl

Authors

  • Adolfo Rodriguez Tsouroukdissian

Joint Limits Interface

Overview

joint_limits_interface contains data structures for representing joint limits, methods for populating them from common formats such as URDF and the ROS parameter server, and methods for enforcing limits on different kinds of hardware interfaces.

The joint_limits_interface is not used by controllers themselves (it does not implement a HardwareInterface) but instead operates after the controllers have updated, in the write() method (or equivalent) of the robot abstraction. Enforcing limits will overwrite the commands set by the controllers, it does not operate on a separate raw data buffer.

There are two main elements involved in setting up a joint limits interface:

  • Joint limits representation
    • JointLimits Position, velocity, acceleration, jerk and effort.
    • SoftJointLimits Soft position limits, k_p, k_v (as described here).
    • Loading from URDF There are convenience methods for loading joint limits information (position, velocity and effort), as well as soft joint limits information from the URDF.
    • Loading from ROS params There are convenience methods for loading joint limits from the ROS parameter server (position, velocity, acceleration, jerk and effort). Parameter specification is the same used in MoveIt, with the addition that we also parse jerk and effort limits.
  • Joint limits interface

  • For effort-controlled joints, the soft-limits implementation from the PR2 has been ported.
  • For position-controlled joints, a modified version of the PR2 soft limits has been implemented.
  • For velocity-controlled joints, simple saturation based on acceleration and velocity limits has been implemented.

Examples

Please refer to the joint_limits_interface wiki page.

CHANGELOG
No CHANGELOG found.

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged joint_limits_interface at Robotics Stack Exchange

No version for distro jazzy showing humble. Known supported distros are highlighted in the buttons above.

Package Summary

Tags No category tags.
Version 0.0.0
License Apache License 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description Generic and simple controls framework for ROS 2
Checkout URI https://github.com/ros-controls/ros2_control.git
VCS Type git
VCS Version humble
Last Updated 2025-08-07
Dev Status DEVELOPED
Released RELEASED
Tags controllers control robotics ros control-systems robot-control ros2 ros2-control ros2-rolling ros2-humble ros2-jazzy
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Interface for enforcing joint limits.

Additional Links

Maintainers

  • Bence Magyar
  • Denis Štogl

Authors

  • Adolfo Rodriguez Tsouroukdissian

Joint Limits Interface

Overview

joint_limits_interface contains data structures for representing joint limits, methods for populating them from common formats such as URDF and the ROS parameter server, and methods for enforcing limits on different kinds of hardware interfaces.

The joint_limits_interface is not used by controllers themselves (it does not implement a HardwareInterface) but instead operates after the controllers have updated, in the write() method (or equivalent) of the robot abstraction. Enforcing limits will overwrite the commands set by the controllers, it does not operate on a separate raw data buffer.

There are two main elements involved in setting up a joint limits interface:

  • Joint limits representation
    • JointLimits Position, velocity, acceleration, jerk and effort.
    • SoftJointLimits Soft position limits, k_p, k_v (as described here).
    • Loading from URDF There are convenience methods for loading joint limits information (position, velocity and effort), as well as soft joint limits information from the URDF.
    • Loading from ROS params There are convenience methods for loading joint limits from the ROS parameter server (position, velocity, acceleration, jerk and effort). Parameter specification is the same used in MoveIt, with the addition that we also parse jerk and effort limits.
  • Joint limits interface

  • For effort-controlled joints, the soft-limits implementation from the PR2 has been ported.
  • For position-controlled joints, a modified version of the PR2 soft limits has been implemented.
  • For velocity-controlled joints, simple saturation based on acceleration and velocity limits has been implemented.

Examples

Please refer to the joint_limits_interface wiki page.

CHANGELOG
No CHANGELOG found.

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged joint_limits_interface at Robotics Stack Exchange

No version for distro kilted showing humble. Known supported distros are highlighted in the buttons above.

Package Summary

Tags No category tags.
Version 0.0.0
License Apache License 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description Generic and simple controls framework for ROS 2
Checkout URI https://github.com/ros-controls/ros2_control.git
VCS Type git
VCS Version humble
Last Updated 2025-08-07
Dev Status DEVELOPED
Released RELEASED
Tags controllers control robotics ros control-systems robot-control ros2 ros2-control ros2-rolling ros2-humble ros2-jazzy
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Interface for enforcing joint limits.

Additional Links

Maintainers

  • Bence Magyar
  • Denis Štogl

Authors

  • Adolfo Rodriguez Tsouroukdissian

Joint Limits Interface

Overview

joint_limits_interface contains data structures for representing joint limits, methods for populating them from common formats such as URDF and the ROS parameter server, and methods for enforcing limits on different kinds of hardware interfaces.

The joint_limits_interface is not used by controllers themselves (it does not implement a HardwareInterface) but instead operates after the controllers have updated, in the write() method (or equivalent) of the robot abstraction. Enforcing limits will overwrite the commands set by the controllers, it does not operate on a separate raw data buffer.

There are two main elements involved in setting up a joint limits interface:

  • Joint limits representation
    • JointLimits Position, velocity, acceleration, jerk and effort.
    • SoftJointLimits Soft position limits, k_p, k_v (as described here).
    • Loading from URDF There are convenience methods for loading joint limits information (position, velocity and effort), as well as soft joint limits information from the URDF.
    • Loading from ROS params There are convenience methods for loading joint limits from the ROS parameter server (position, velocity, acceleration, jerk and effort). Parameter specification is the same used in MoveIt, with the addition that we also parse jerk and effort limits.
  • Joint limits interface

  • For effort-controlled joints, the soft-limits implementation from the PR2 has been ported.
  • For position-controlled joints, a modified version of the PR2 soft limits has been implemented.
  • For velocity-controlled joints, simple saturation based on acceleration and velocity limits has been implemented.

Examples

Please refer to the joint_limits_interface wiki page.

CHANGELOG
No CHANGELOG found.

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged joint_limits_interface at Robotics Stack Exchange

No version for distro rolling showing humble. Known supported distros are highlighted in the buttons above.

Package Summary

Tags No category tags.
Version 0.0.0
License Apache License 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description Generic and simple controls framework for ROS 2
Checkout URI https://github.com/ros-controls/ros2_control.git
VCS Type git
VCS Version humble
Last Updated 2025-08-07
Dev Status DEVELOPED
Released RELEASED
Tags controllers control robotics ros control-systems robot-control ros2 ros2-control ros2-rolling ros2-humble ros2-jazzy
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Interface for enforcing joint limits.

Additional Links

Maintainers

  • Bence Magyar
  • Denis Štogl

Authors

  • Adolfo Rodriguez Tsouroukdissian

Joint Limits Interface

Overview

joint_limits_interface contains data structures for representing joint limits, methods for populating them from common formats such as URDF and the ROS parameter server, and methods for enforcing limits on different kinds of hardware interfaces.

The joint_limits_interface is not used by controllers themselves (it does not implement a HardwareInterface) but instead operates after the controllers have updated, in the write() method (or equivalent) of the robot abstraction. Enforcing limits will overwrite the commands set by the controllers, it does not operate on a separate raw data buffer.

There are two main elements involved in setting up a joint limits interface:

  • Joint limits representation
    • JointLimits Position, velocity, acceleration, jerk and effort.
    • SoftJointLimits Soft position limits, k_p, k_v (as described here).
    • Loading from URDF There are convenience methods for loading joint limits information (position, velocity and effort), as well as soft joint limits information from the URDF.
    • Loading from ROS params There are convenience methods for loading joint limits from the ROS parameter server (position, velocity, acceleration, jerk and effort). Parameter specification is the same used in MoveIt, with the addition that we also parse jerk and effort limits.
  • Joint limits interface

  • For effort-controlled joints, the soft-limits implementation from the PR2 has been ported.
  • For position-controlled joints, a modified version of the PR2 soft limits has been implemented.
  • For velocity-controlled joints, simple saturation based on acceleration and velocity limits has been implemented.

Examples

Please refer to the joint_limits_interface wiki page.

CHANGELOG
No CHANGELOG found.

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged joint_limits_interface at Robotics Stack Exchange

Package Summary

Tags No category tags.
Version 0.13.3
License BSD
Build type CATKIN
Use RECOMMENDED

Repository Summary

Description This ROS workspace is created on Raspbian OS. Here I have installed ROS Kinetic from source using cross-compilation and worked on projects like Surveilling Robot.
Checkout URI https://github.com/iamrajee/roskinetic_catkin_ws.git
VCS Type git
VCS Version master
Last Updated 2022-03-04
Dev Status UNKNOWN
Released UNRELEASED
Tags cmake ros raspbian catkin raspberry-pi-3 realsense ros-kinetic gmapping-slam realsense-camera
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Interface for enforcing joint limits.

Additional Links

Maintainers

  • Bence Magyar
  • Enrique Fernandez
  • Mathias Lüdtke

Authors

  • Adolfo Rodriguez Tsouroukdissian

Joint Limits Interface

Overview

joint_limits_interface contains data structures for representing joint limits, methods for populating them from common formats such as URDF and the ROS parameter server, and methods for enforcing limits on different kinds of hardware interfaces.

The joint_limits_interface is not used by controllers themselves (it does not implement a HardwareInterface) but instead operates after the controllers have updated, in the write() method (or equivalent) of the robot abstraction. Enforcing limits will overwrite the commands set by the controllers, it does not operate on a separate raw data buffer.

There are two main elements involved in setting up a joint limits interface:

  • Joint limits representation
    • JointLimits Position, velocity, acceleration, jerk and effort.
    • SoftJointLimits Soft position limits, k_p, k_v (as described here).
    • Loading from URDF There are convenience methods for loading joint limits information (position, velocity and effort), as well as soft joint limits information from the URDF.
    • Loading from ROS params There are convenience methods for loading joint limits from the ROS parameter server (position, velocity, acceleration, jerk and effort).Parameter specification is the same used in MoveIt, with the addition that we also parse jerk and effort limits.
  • Joint limits interface

  • For effort-controlled joints, the soft-limits implementation from the PR2 has been ported.
  • For position-controlled joints, a modified version of the PR2 soft limits has been implemented.
  • For velocity-controlled joints, simple saturation based on acceleration and velocity limits has been implemented.

Examples

Please refer to the joint_limits_interface wiki page.

CHANGELOG

Changelog for package joint_limits_interface

0.13.3 (2018-04-26)

  • Update maintainers
  • Fix catkin_lint errors and warnings
  • Contributors: Bence Magyar

0.13.2 (2018-04-16)

0.13.1 (2018-03-26)

0.13.0 (2017-12-23)

  • Add method to populate SoftJointLimits from ROS parameter server. (#292)
  • Contributors: Miguel Prada

0.12.0 (2017-08-05)

0.11.5 (2017-06-28)

  • Throw error if EffortJointSaturationHandle is missing effort or velocity limits
  • Contributors: Bence Magyar, Dave Coleman

0.11.4 (2017-02-14)

0.11.3 (2016-12-07)

  • Add urdf compatibility header
  • Contributors: Bence Magyar

0.11.2 (2016-11-28)

  • Add Enrique and Bence to maintainer list
  • Clean up export leftovers from rosbuild
  • Convert to format2, fix dependency in cmake
  • Replace boost::shared_ptr<urdf::XY> with urdf::XYConstSharedPtr
  • Contributors: Bence Magyar

0.11.1 (2016-08-18)

0.11.0 (2016-05-23)

0.10.1 (2016-04-23)

  • Fix catkin_package
    • Don't export local include dirs.
    • Fix dependency on urdfdom (Thanks to Mathias Lüdtke).
  • Contributors: Jochen Sprickerhof

0.10.0 (2015-11-20)

0.9.3 (2015-05-05)

0.9.2 (2015-05-04)

  • Reset functionality for stateful position joint limit handles
  • Contributors: Mathias Lüdtke

0.9.1 (2014-11-03)

0.9.0 (2014-10-31)

  • Buildsystem and documentation fixes
  • Add inline keyword to free header functions
  • Contributors: Adolfo Rodriguez Tsouroukdissian, Lukas Bulwahn, shadowmanos

0.8.2 (2014-06-25)

  • Propagate urdfdom changes to CMakeLists.txt urdfdom is now standalone, so it must be find_package'd independently.
  • Fix rostest, which was not being built correctly.
  • Contributors: Adolfo Rodriguez Tsouroukdissian

0.8.1 (2014-06-24)

  • Use upstream liburdfdom-dev package. Refs ros/rosdistro#4633.
  • Contributors: Adolfo Rodriguez Tsouroukdissian

0.8.0 (2014-05-12)

  • Remove rosbuild artifacts. Fix #154.
  • Contributors: Adolfo Rodriguez Tsouroukdissian

0.7.2 (2014-04-01)

0.7.1 (2014-03-31)

  • Fix dependency specification in CMake script to allow isolated builds.
  • Contributors: Adolfo Rodriguez Tsouroukdissian

0.7.0 (2014-03-28)

0.6.0 (2014-02-05)

File truncated at 100 lines see the full file

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged joint_limits_interface at Robotics Stack Exchange

Package Summary

Tags No category tags.
Version 0.0.0
License Apache License 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description Generic and simple controls framework for ROS 2
Checkout URI https://github.com/ros-controls/ros2_control.git
VCS Type git
VCS Version galactic
Last Updated 2022-08-03
Dev Status DEVELOPED
Released RELEASED
Tags controllers control robotics ros control-systems robot-control ros2 ros2-control ros2-rolling ros2-humble ros2-jazzy
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Interface for enforcing joint limits.

Additional Links

Maintainers

  • Bence Magyar
  • Jordan Palacios

Authors

  • Adolfo Rodriguez Tsouroukdissian

Joint Limits Interface

Overview

joint_limits_interface contains data structures for representing joint limits, methods for populating them from common formats such as URDF and the ROS parameter server, and methods for enforcing limits on different kinds of hardware interfaces.

The joint_limits_interface is not used by controllers themselves (it does not implement a HardwareInterface) but instead operates after the controllers have updated, in the write() method (or equivalent) of the robot abstraction. Enforcing limits will overwrite the commands set by the controllers, it does not operate on a separate raw data buffer.

There are two main elements involved in setting up a joint limits interface:

  • Joint limits representation
    • JointLimits Position, velocity, acceleration, jerk and effort.
    • SoftJointLimits Soft position limits, k_p, k_v (as described here).
    • Loading from URDF There are convenience methods for loading joint limits information (position, velocity and effort), as well as soft joint limits information from the URDF.
    • Loading from ROS params There are convenience methods for loading joint limits from the ROS parameter server (position, velocity, acceleration, jerk and effort). Parameter specification is the same used in MoveIt, with the addition that we also parse jerk and effort limits.
  • Joint limits interface

  • For effort-controlled joints, the soft-limits implementation from the PR2 has been ported.
  • For position-controlled joints, a modified version of the PR2 soft limits has been implemented.
  • For velocity-controlled joints, simple saturation based on acceleration and velocity limits has been implemented.

Examples

Please refer to the joint_limits_interface wiki page.

CHANGELOG
No CHANGELOG found.

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged joint_limits_interface at Robotics Stack Exchange

Package Summary

Tags No category tags.
Version 0.0.0
License Apache License 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description Generic and simple controls framework for ROS 2
Checkout URI https://github.com/ros-controls/ros2_control.git
VCS Type git
VCS Version iron
Last Updated 2024-11-14
Dev Status DEVELOPED
Released RELEASED
Tags controllers control robotics ros control-systems robot-control ros2 ros2-control ros2-rolling ros2-humble ros2-jazzy
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Interface for enforcing joint limits.

Additional Links

Maintainers

  • Bence Magyar
  • Denis Štogl

Authors

  • Adolfo Rodriguez Tsouroukdissian

Joint Limits Interface

Overview

joint_limits_interface contains data structures for representing joint limits, methods for populating them from common formats such as URDF and the ROS parameter server, and methods for enforcing limits on different kinds of hardware interfaces.

The joint_limits_interface is not used by controllers themselves (it does not implement a HardwareInterface) but instead operates after the controllers have updated, in the write() method (or equivalent) of the robot abstraction. Enforcing limits will overwrite the commands set by the controllers, it does not operate on a separate raw data buffer.

There are two main elements involved in setting up a joint limits interface:

  • Joint limits representation
    • JointLimits Position, velocity, acceleration, jerk and effort.
    • SoftJointLimits Soft position limits, k_p, k_v (as described here).
    • Loading from URDF There are convenience methods for loading joint limits information (position, velocity and effort), as well as soft joint limits information from the URDF.
    • Loading from ROS params There are convenience methods for loading joint limits from the ROS parameter server (position, velocity, acceleration, jerk and effort). Parameter specification is the same used in MoveIt, with the addition that we also parse jerk and effort limits.
  • Joint limits interface

  • For effort-controlled joints, the soft-limits implementation from the PR2 has been ported.
  • For position-controlled joints, a modified version of the PR2 soft limits has been implemented.
  • For velocity-controlled joints, simple saturation based on acceleration and velocity limits has been implemented.

Examples

Please refer to the joint_limits_interface wiki page.

CHANGELOG
No CHANGELOG found.

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged joint_limits_interface at Robotics Stack Exchange

Package Summary

Tags No category tags.
Version 0.18.4
License BSD
Build type CATKIN
Use RECOMMENDED

Repository Summary

Description Generic and simple controls framework for ROS
Checkout URI https://github.com/ros-controls/ros_control.git
VCS Type git
VCS Version melodic-devel
Last Updated 2023-10-27
Dev Status MAINTAINED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Interface for enforcing joint limits.

Additional Links

Maintainers

  • Bence Magyar
  • Enrique Fernandez
  • Mathias Lüdtke

Authors

  • Adolfo Rodriguez Tsouroukdissian

Joint Limits Interface

Overview

joint_limits_interface contains data structures for representing joint limits, methods for populating them from common formats such as URDF and the ROS parameter server, and methods for enforcing limits on different kinds of hardware interfaces.

The joint_limits_interface is not used by controllers themselves (it does not implement a HardwareInterface) but instead operates after the controllers have updated, in the write() method (or equivalent) of the robot abstraction. Enforcing limits will overwrite the commands set by the controllers, it does not operate on a separate raw data buffer.

There are two main elements involved in setting up a joint limits interface:

  • Joint limits representation
    • JointLimits Position, velocity, acceleration, jerk and effort.
    • SoftJointLimits Soft position limits, k_p, k_v (as described here).
    • Loading from URDF There are convenience methods for loading joint limits information (position, velocity and effort), as well as soft joint limits information from the URDF.
    • Loading from ROS params There are convenience methods for loading joint limits from the ROS parameter server (position, velocity, acceleration, jerk and effort).Parameter specification is the same used in MoveIt, with the addition that we also parse jerk and effort limits.
  • Joint limits interface

  • For effort-controlled joints, the soft-limits implementation from the PR2 has been ported.
  • For position-controlled joints, a modified version of the PR2 soft limits has been implemented.
  • For velocity-controlled joints, simple saturation based on acceleration and velocity limits has been implemented.

Examples

Please refer to the joint_limits_interface wiki page.

CHANGELOG

Changelog for package joint_limits_interface

0.18.4 (2021-06-16)

0.18.3 (2020-12-05)

  • Update docs in hardware_interface
  • Contributors: Franz Pucher

0.18.2 (2020-08-17)

0.18.1 (2020-05-09)

  • Add function specifiers and modernize constructors (#430)
    • Add override specifiers & default constructors
    • Delete ControllerBase copy & move ctors
    • Remove unnecessary default constructors
    • Modernize additional constructors
    • Revert ImuSensorHandle::<Data::Data>() = default
    • Remove unnecessary default overridden constructors
    • Remove semicolon after function body
  • Contributors: Matt Reynolds

0.18.0 (2020-04-16)

  • Bump CMake version to avoid CMP0048 (#427)
  • Contributors: Shane Loretz

0.17.0 (2020-02-24)

  • Use default member initializers
  • Use braces for member initializers
  • Replace boost with std
  • Replace boost ptrs with std ptrs in documentation
  • Prefer default member initializers
  • Contributors: AbhinavSingh, Bence Magyar, Matt Reynolds

0.16.0 (2020-01-27)

  • Merge pull request #413 from matthew-reynolds/range-for Use range-based for loop
  • Use more meaningful pair iterator names
  • Merge pull request #404 from matthew-reynolds/catkin-lint Update CMakeLists.txt and package.xml
  • Use range-based for loops in joint_limits_interface
  • Update dependencies
    • Dependencies needed to compile are <build_depend>
    • Dependencies used in public headers are <build_export_depend>
    • Dependencies needed to link or run are <exec_depend>
  • Merge branch 'melodic-devel' into catkin-lint
  • Update package dependencies
  • Remove liburdfdom-dev
  • Add missing roscpp & rospy dependencies
  • Remove rosunit test_depend from package.xml
  • Merge pull request #405 from matthew-reynolds/use-nullptr Use nullptr
  • Prefer 0.0 for floating point literals
  • Merge pull request #406 from matthew-reynolds/pragma-once Use #pragma once
  • Replace header guard with #pragma once
  • Merge pull request #395 from pal-robotics-forks/extend-interfaces-melodic Extend interfaces
  • joint_limits: use an open-loop policy for velocity staturation The feedback from the controller is way too slow to be used on an actual robot. A robot that had 15 rad.s\^-2 on each wheel as an acceleration limit could not even reach 2 rad.s\^-2 This is in line with ros_controllers#23
  • Apply consistent style to CMakeLists.txt files
  • Apply consistent style to package.xml files
  • Merge pull request #398 from matthew-reynolds/revert-cmake Revert CMake include_directories as SYSTEM
  • Revert CMake include_directories as SYSTEM
  • Merge pull request #396 from pal-robotics-forks/small-fixes Small fixes
  • Fix shadowed variables
  • -Werror=overloaded-virtual and initialization of fields in constructor
  • Contributors: Bence Magyar, Daniel Pinyol, Matt Reynolds, Paul Mathieu, Victor Lopez

0.15.1 (2018-09-30)

0.15.0 (2018-05-28)

0.14.2 (2018-04-26)

  • Update maintainers
  • Fix catkin_lint errors and warnings
  • Contributors: Bence Magyar

File truncated at 100 lines see the full file

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged joint_limits_interface at Robotics Stack Exchange

Package Summary

Tags No category tags.
Version 0.20.0
License BSD
Build type CATKIN
Use RECOMMENDED

Repository Summary

Description Generic and simple controls framework for ROS
Checkout URI https://github.com/ros-controls/ros_control.git
VCS Type git
VCS Version noetic-devel
Last Updated 2024-10-12
Dev Status MAINTAINED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Interface for enforcing joint limits.

Additional Links

Maintainers

  • Bence Magyar
  • Enrique Fernandez
  • Mathias Lüdtke

Authors

  • Adolfo Rodriguez Tsouroukdissian

Joint Limits Interface

Overview

joint_limits_interface contains data structures for representing joint limits, methods for populating them from common formats such as URDF and the ROS parameter server, and methods for enforcing limits on different kinds of hardware interfaces.

The joint_limits_interface is not used by controllers themselves (it does not implement a HardwareInterface) but instead operates after the controllers have updated, in the write() method (or equivalent) of the robot abstraction. Enforcing limits will overwrite the commands set by the controllers, it does not operate on a separate raw data buffer.

There are two main elements involved in setting up a joint limits interface:

  • Joint limits representation
    • JointLimits Position, velocity, acceleration, jerk and effort.
    • SoftJointLimits Soft position limits, k_p, k_v (as described here).
    • Loading from URDF There are convenience methods for loading joint limits information (position, velocity and effort), as well as soft joint limits information from the URDF.
    • Loading from ROS params There are convenience methods for loading joint limits from the ROS parameter server (position, velocity, acceleration, jerk and effort).Parameter specification is the same used in MoveIt, with the addition that we also parse jerk and effort limits.
  • Joint limits interface

  • For effort-controlled joints, the soft-limits implementation from the PR2 has been ported.
  • For position-controlled joints, a modified version of the PR2 soft limits has been implemented.
  • For velocity-controlled joints, simple saturation based on acceleration and velocity limits has been implemented.

Examples

Please refer to the joint_limits_interface wiki page.

CHANGELOG

Changelog for package joint_limits_interface

0.20.0 (2023-10-27)

0.19.6 (2022-10-21)

0.19.5 (2021-06-16)

0.19.4 (2020-12-05)

0.19.3 (2020-10-11)

0.19.2 (2020-08-17)

0.19.1 (2020-05-10)

  • Function specifiers noetic (#453)

    • Add override specifiers & default constructors
    • Delete ControllerBase copy & move ctors
    • Remove unnecessary default constructors
    • Modernize additional constructors
    • Revert ImuSensorHandle::<Data::Data>() = default
    • Remove unnecessary default overridden constructors

    * Remove semicolon after function body Co-authored-by: Matt Reynolds <<mtreynolds@uwaterloo.ca>>

  • Use setuptools instead of distutils (#429)

  • Contributors: Bence Magyar, Matt Reynolds

0.19.0 (2020-04-23)

0.18.0 (2020-04-16)

  • Bump CMake version to avoid CMP0048 (#427)
  • Contributors: Shane Loretz

0.17.0 (2020-02-24)

  • Use default member initializers
  • Use braces for member initializers
  • Replace boost with std
  • Replace boost ptrs with std ptrs in documentation
  • Prefer default member initializers
  • Contributors: AbhinavSingh, Bence Magyar, Matt Reynolds

0.16.0 (2020-01-27)

  • Merge pull request #413 from matthew-reynolds/range-for Use range-based for loop
  • Use more meaningful pair iterator names
  • Merge pull request #404 from matthew-reynolds/catkin-lint Update CMakeLists.txt and package.xml
  • Use range-based for loops in joint_limits_interface
  • Update dependencies
    • Dependencies needed to compile are <build_depend>
    • Dependencies used in public headers are <build_export_depend>
    • Dependencies needed to link or run are <exec_depend>
  • Merge branch 'melodic-devel' into catkin-lint
  • Update package dependencies
  • Remove liburdfdom-dev
  • Add missing roscpp & rospy dependencies
  • Remove rosunit test_depend from package.xml
  • Merge pull request #405 from matthew-reynolds/use-nullptr Use nullptr
  • Prefer 0.0 for floating point literals
  • Merge pull request #406 from matthew-reynolds/pragma-once Use #pragma once
  • Replace header guard with #pragma once
  • Merge pull request #395 from pal-robotics-forks/extend-interfaces-melodic Extend interfaces
  • joint_limits: use an open-loop policy for velocity staturation The feedback from the controller is way too slow to be used on an actual robot. A robot that had 15 rad.s\^-2 on each wheel as an acceleration limit could not even reach 2 rad.s\^-2 This is in line with ros_controllers#23
  • Apply consistent style to CMakeLists.txt files
  • Apply consistent style to package.xml files
  • Merge pull request #398 from matthew-reynolds/revert-cmake Revert CMake include_directories as SYSTEM
  • Revert CMake include_directories as SYSTEM
  • Merge pull request #396 from pal-robotics-forks/small-fixes Small fixes
  • Fix shadowed variables
  • -Werror=overloaded-virtual and initialization of fields in constructor

File truncated at 100 lines see the full file

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged joint_limits_interface at Robotics Stack Exchange