IK_NR - Newton-Raphson Numerical IK

class roboticstoolbox.robot.IK.IK_NR(name='IK Solver', ilimit=30, slimit=100, tol=1e-06, mask=None, joint_limits=True, seed=None, pinv=False, kq=0.0, km=0.0, ps=0.0, pi=0.3, **kwargs)[source]

Bases: IKSolver

Newton-Raphson Numerical Inverse Kinematics Solver

A class which provides functionality to perform numerical inverse kinematics (IK) using the Newton-Raphson method. See step method for mathematical description.

Note

When using this class with redundant robots (>6 DoF), pinv must be set to True

Parameters:

  • name (str) – The name of the IK algorithm

  • ilimit (int) – How many iterations are allowed within a search before a new search is started

  • slimit (int) – How many searches are allowed before being deemed unsuccessful

  • tol (float) – Maximum allowed residual error E

  • mask (Union[ndarray, List[float], Tuple[float, ...], None]) – A 6 vector which assigns weights to Cartesian degrees-of-freedom error priority

  • joint_limits (bool) – Reject solutions with joint limit violations

  • seed (int | None) – A seed for the private RNG used to generate random joint coordinate vectors

  • pinv (bool) – If True, will use the psuedoinverse in the step method instead of the normal inverse

  • kq (float) – The gain for joint limit avoidance. Setting to 0.0 will remove this completely from the solution

  • km (float) – The gain for maximisation. Setting to 0.0 will remove this completely from the solution

  • ps (float) – The minimum angle/distance (in radians or metres) in which the joint is allowed to approach to its limit

  • pi (ndarray | float) – The influence angle/distance (in radians or metres) in null space motion becomes active

Example:

The following example gets the ``ets`` of a ``panda`` robot object, instantiates
the IK_NR solver class using default parameters, makes a goal pose ``Tep``,
and then solves for the joint coordinates which result in the pose ``Tep``
using the ``solve`` method.

>>> import roboticstoolbox as rtb
>>> panda = rtb.models.Panda().ets()
>>> solver = rtb.IK_NR(pinv=True)
>>> Tep = panda.fkine([0, -0.3, 0, -2.2, 0, 2, 0.7854])
>>> solver.solve(panda, Tep)
IKSolution(q=array([-2.3695,  0.3956,  2.4655, -2.1919, -0.2776,  1.9654,  1.004 ]), success=True, iterations=22, searches=2, residual=8.488717747015899e-10, reason='Success')

Notes

When using the NR method, the initial joint coordinates \(q_0\), should correspond to a non-singular manipulator pose, since it uses the manipulator Jacobian. When the the problem is solvable, it converges very quickly. However, this method frequently fails to converge on the goal.

This class supports null-space motion to assist with maximising manipulability and avoiding joint limits. These are enabled by setting kq and km to non-zero values.

References

  • J. Haviland, and P. Corke. “Manipulator Differential Kinematics Part I: Kinematics, Velocity, and Applications.” arXiv preprint arXiv:2207.01796 (2022).

  • J. Haviland, and P. Corke. “Manipulator Differential Kinematics Part II: Acceleration and Advanced Applications.” arXiv preprint arXiv:2207.01794 (2022).

See also

IKSolver An abstract super class for numerical IK solvers

IK_GN Implements the IKSolver class using the Gauss-Newton method

IK_LM Implements the IKSolver class using the Levemberg-Marquadt method

IK_QP Implements the IKSolver class using a quadratic programming approach

Changed in version 1.0.3: Added the Newton-Raphson IK solver class

Methods

step(ets, Tep, q)

Performs a single iteration of the Newton-Raphson optimisation method

solve(ets, Tep[, q0])

Solves the IK problem

error(Te, Tep)

Calculates the error between Te and Tep

Private Methods

_random_q(ets[, i])

Generate a random valid joint configuration using a private RNG

_check_jl(ets, q)

Checks if the joints are within their respective limits