ruckig

This release brings various new features and improvements, most notably support for infinite jerk and acceleration limits.

⚡ Features

• Support for both infinite and zero kinematic limits.
• Detailed error message on failed input validation.
• Expose the current jerk value in the output.
• Performance improvements for the velocity interface.
• Enable the Cloud API for intermediate waypoints by default.

🐛 Fixes

• Reworked the Python wheel build pipeline, fixes macOS wheels for Python 3.11+ and brings support for a wider range of architectures and distributions.

🔬 Misc

• Added Python linting to the CI.
• Easily create Debian packages with CPack.
• Renamed the PositionExtrema class to Bound.

This patch release improves the general performance of Ruckig.

⚡️ Features

• Improvement of the calculation performance by up to 10%.
• Added support for Python 3.11, including pre-built packages for PyPI.

🐛 Fixes

• Fixed several minor issues with C++11 support via the patch.
• Fixed several MSVC Warnings in the OnlineCalculator class.

This release includes two exciting new features: First, it extends phase synchronization for straight-line trajectories to the velocity control interface. Second, this release allows to use custom vector types (with support for Eigen types out of the box) for an easier interface to your code without any wrappers.

⚡ Features

• Extends phase synchronization to the velocity control mode.
• Introduces custom vector types that can be specified as a template template argument. More information can be found in the Readme section.
• Built-in support for nlohmann/json based serialization of the trajectory class.
• Adds a pyproject.toml file for easier setup of the Python module.

🐛 Fixes

• Fixes trajectory calculations when the current acceleration is on its limit due to an issue with the braking trajectory.
• Removes -Werror as a default flag to let Ruckig build in case of compiler warnings.

🥇 Sponsors

Thanks to Fuzzy Logic Robotics for sponsoring this release!

With this release, Ruckig allows using a variable control rate!

⚡ Features

• Makes delta_time non-constant.
• Allows to reset Ruckig and therefore force a new trajectory computation (#132).

🐛 Fixes

• Improves the stability of the velocity control as well as the discrete duration mode (e.g. #116).
• Fixes independent_min_duration in case of a brake trajectory (#128).
• Fixes a rare issue where the first update does not calculate a trajectory (#115).
• Fixes warnings for MSVC (e.g. #127, #133).

🐛 Fixes

• Fixes a numerical instability in velocity control, in particular when calculating trajectories to a zero target state.
• Fixes pip install for non-prebuild architectures.
• Fixes an error when building the Online API flag (BUILD_ONLINE_CLIENT) with some C++17 compilers due to the nlohmann/json dependency.

⚡ Features

• Improves the computational performance by around 10%.
• Adds continuous deployment of ROS packages via GitHub Actions.

This release brings trajectories with intermediate waypoints to the Community Version! Calculation is done on remote servers via this API, so this is only applicable for offline trajectory generation. Furthermore, this release...

⚡ Features

• Adds a method for filtering intermediate waypoints based on a threshold distance for each DoF. In general, Ruckig prefers as few waypoints as possible, so we recommend to filter the input with a threshold as high as possible.
• Improves input validation. In particular, Ruckig is now able to guarantee the kinematic state to be below the constraints throughout the trajectory.

🐛 Fixes

• Fixes trajectories with zero duration.
• Adds a stability improvement to Step 2 of the algorithm.

This release introduces the pass_to_input method of the OutputParameter class: We recommend to change the following usage in your code from

while (ruckig.update(input, output) == Result::Working) {
  // Make use of the new state here!

  input.current_position = output.new_position;
  input.current_velocity = output.new_velocity;
  input.current_acceleration = output.new_acceleration;
}

to

while (ruckig.update(input, output) == Result::Working) {
  // Make use of the new state here!

  output.pass_to_input(input);
}

While the old style works fine for now, it is now depreciated to support additional features coming in future releases. Moreover, this release includes:

⚡ Features

• Introduces the option to set the synchronization and control interface for each degree of freedom separately.
• An overall performance improvement of around 15%.
• Reduced the memory footprint of the Trajectory class by an order of magnitude.

🐛 Fixes

• Fixed a jump in the position output after a finished trajectory for disabled degrees of freedom.

🔬 Misc

• Added a to_string method for printing the OutputParameter class (#77).

⚡ Features

• Ruckig now allows a dynamic number of DoFs with ruckig::DynamicDOFs. In particular, this allows the Python wrapper to be used with any number of DoF (#47).
• Improved the performance for trajectory calculation by around 30%.
• Added offline trajectory calculation without the need of a control cycle time.
• Added the get_first_time_at_position method to calculate when a specific position is reached.

🐛 Bug Fixes

• Improved numeric stability, in particular for very long trajectories and very high limits.
• Fixed min_velocity in phase synchronization.
• Fixed several smaller bugs and compiler warnings.

🤖 Tests

• Added tests for secondary features like input validation, inverse position calculation, etc...

This release adds a pre-compiled Python package for Windows on PyPI!

This release fixes two issues mostly regarding Windows. 🐛

• Fixes an issue when building from the Python source package (#40)
• Fixes the Python bindings using MSVC (#37)

This release primarily improves the numerical stability of Ruckig. In particular, we added tests (and fixed several issues) for difficult cases by stepping through time-optimal trajectories.

⚡ Features

• Added optional phase synchronization for straight-line trajectories (#13)

🐛 Bug Fixes

• Try to recalculate trajectory in the case of errors (#20)
• Improved numeric stability for inputs with different order of magnitudes (#27)
• Fixed a numeric bug for very small negative position differences (#30)
• Fixes in the position extremum calculation (#33)
• Fixes when calculating whether phase synchronization is possible (#32)
• The Python wrapper for the at_time method now returns the new kinematic state (#34)
• Fixed several compilation warnings and treat them as errors furthermore

🤖 Tests

• Add tests for stepping through calculated trajectories
• Add tests for directional dependent velocity and acceleration constraints
• Add tests for extremal position calculation

🐍 Python

• Ruckig now has a Python package at PyPI! It can be installed via pip install ruckig.

We made large steps towards a full-featured trajectory generator. This includes:

⚡ Features

• Added velocity Interface for velocity-control.
• Added setting for different time synchronization behaviors regarding multiple degrees of freedom.
• Added optional minimum acceleration limit, similar to the minimum velocity limit.
• Scaled tests to over 1.000.000.000 trajectories (100x improvement).
• Improved performance and overtook Reflexxes Type IV in comparison.
• Lot's of supplements and fixes for the Readme.
• Moved tests to doctest for faster compilations.

🐛 Fixes

• Fixes real-time capability with own set container.
• Fixes behavior after finishing the trajectory.
• Now compiles without any warnings and errors on GCC and Clang.

First version with full support for target accelerations in multiple DoFs! 🎉

• Added min velocity limit.
• Added Doxygen-generated documentation and auto-publish via CI.
• More tests. Now over 1.400.000 random multi-dof trajectories.
• Added a benchmark for measuing the performance.
• Lot's of code cleaning and optimizations.
• Removed Eigen dependency.