A python based system for generating closed-form solutions to the manipulator inverse kinematics problem using behavior trees for action selection. Solutions are fully symbolic and are output as LaTex, Python, and C++.

• We have done a complete re-write of the solution set generation process with seemingly good results. We develop the table of solutions directly instead of relying on a solution graph, adding rows as each solved variable creates combinations Explanation and Example

• One of our main learnings earlier in this project was that robot kinematic equation solutions in general are NOT described by a tree structure! Instead they are a more general graph. Our previous solution was overly complex due to lingering assumptions from the tree structure idea.

• Current status is that FK and IK solutions seem correct, latex output is correct and shows all versions. A new section in the Latex output also gives generic "textbook" style solutions without all the solution set permutations. We have not yet done a full "closed loop" test on these new solution vectors as described in the JAIR paper.

• New solution version system is fully integrated with Latex, Cpp, and Python generation outputs.

• The new approach to solution sets is explained in a document IKdocs/solExample.pdf.

• There is lots of code from the old method ("v2") that need to be cleaned up, as well as several superfluous class members in Robot and unknown classes.

• New feature: Can generate python code for Forward Kinematics only. This code can be sub-optimal, and equations can be over complex when the alpha parameter is not a nice multiple of pi/2 (sin(al) != {0,1}). This is the case for a few robots like Raven-II. Now in this case constants with the sine and cosine values of alpha are automatically created and swapped in to the FK equations. Generated code initializes the new constants. Try >python3 fkOnly <RobotName>. Output is in the CodeGen directory.

1. We built an autonomous inverse kinematics solver (IKBT) using a behavior tree to organize solution algorithms.
2. We incorporated knowledge frequently used (by human experts) when solving inverse kinematics into a behavior tree. These rule-based solvers applicable to any serial-chain, non-redundant, robot arm.
3. IKBT generates a dependency {\it graph} of joint variables after solving, generating all possible solutions.
4. IKBT provides convenience features such as automatic documentation of the solution in \LaTeX and automatic code generation in Python and C++.
5. Implementation in a modern open-source, cross-platform, programming language (Python) with minimal dependencies outside of the standard Python distribution ({\tt sympy}).

• Current list of Forks

• Introductory Video (6min)
• How to set up IKBT for your own robot arm (6.5min)

• Theory of Operation
• Major Classes
• Solution Set Generation Strategy Doc (updated June 2024)

Zhang, Dianmu, and Blake Hannaford. "IKBT: solving symbolic inverse kinematics with behavior tree." Journal of Artificial Intelligence Research 65 (2019): 457-486. Link

Zhang, Dianmu, and Blake Hannaford. "IKBT: solving closed-form Inverse Kinematics with Behavior Tree." arXiv preprint arXiv:1711.05412 (2017). Link

You need the following to be installed to run IKBT:

• Python 3.8.x (Python Installation)
• Sympy python package (Installation instructions for all OS)
• Latex package (for nice equation output - highly recommended) (Install Latex)

A list of all DH parameters tested in the paper: ['Puma', 'Chair_Helper', 'Wrist', 'MiniDD', 'Olson13','Stanford', 'Sims11', 'Srisuan11', 'Axtman13', 'Mackler13', 'Minder13', 'Palm13', 'Parkman13', 'Frei13', 'Wachtveitl', 'Bartell', 'DZhang', 'Khat6DOF'.]

We suggest you first run the Wrist since it is relatively fast:

python ikSolver.py Wrist

To solve your own problem open the file ikbtfunctions/ik_robots.py and create an entry for your robot. You should copy an entry for an existing robot and edit it's entries. Create an "unknown" for each joint variable and package them into the vector "variables". Enter the DH parameters in matrix form. Also, enter the name of your robot into the list of valid names (ikbtfunctions/ik_robots.py, line 31).

DH parameters explained: The vector "vv" encodes whether each joint is rotary (1) or prismatic (0). If your robot is less than 6 DOF, create empty rows: [ 0 , 0, 0, 0 ], in the DH table so that it has six rows. Many standard symbols in robot kinematics are pre-defined for you but if you use any new ones, be sure to define them using sp.var(). See "Wrist" for an example in which the three joint variables "A, B, C" are set up for sympy by sp.var('A B C'). "pvals" is where you can put in the numerical values for all parameters, for result verification purposes.

Pre-computed forward kinematics.

Sometimes computation of the forward kinematic equations (and their subsequent simplification) can be time consuming. When debugging an inverse kinematics solution (for example modifying the BT), it can slow the cycle if these have to be redone each time. Therefore, the software has a mechanism using Python "pickle" files, to cache the forward kinematics computation and not repeat it. Forward kinematics pickle files are stored in the directory fk_eqns/. This directory will be automatically created if you don't have it. In some cases you may have to delete the pickle file for your robot. To do that, >rm fk_eqns/NAME_pickle.p. IKBT will generally tell you when you should do this, but it is OK to just >rm -rf fk_eqns/ .