An Error-Adaptive Competition-Based Inverse Kinematics Approach for Bimanual Trajectory Tracking of Humanoid Upper-Limb Robots

Humanoid upper-limb robots are an important direction in biomimetic robotics, and inverse kinematics is a key technique for achieving human-like coordinated operation. However, existing inverse kinematics methods for bimanual trajectory tracking often suffer from high computational complexity and limited synchronization performance. To address this, this paper proposes an error-adaptive competition-based inverse kinematics (EAC-IK) approach for bimanual trajectory tracking of humanoid upper-limb robots. First, a unified modeling framework for the absolute tracking errors and synchronization errors of the two arms is established, and the end-effector task constraints are reformulated into a low-dimensional representation, thereby reducing the computational complexity of the original high-dimensional task mapping. Second, to enhance the coordination capability of bimanual operations, an error-adaptive competition mechanism is developed to regulate the weighting coefficients of the two arms online according to their error states. In addition, a virtual second-order command shaper is introduced at the joint level to reconstruct joint trajectories and suppress oscillations induced by input noise and the error-adaptive competition mechanism. Simulation and experimental results on a hyper-redundant humanoid upper-limb robot demonstrate that, compared with the zeroing neural-network-based inverse kinematics method, the proposed method achieves lower tracking and synchronization errors, as well as higher computational efficiency. In the circular trajectory-tracking experiment, the left-arm position and orientation tracking errors decrease from $1.60\times {10}^{-3}\mathrm{m}$ and $4.72\times {10}^{-3}\mathrm{rad}$ to $0.70\times {10}^{-3}\mathrm{m}$ and $0.95\times {10}^{-3}\mathrm{rad}$, respectively, while the synchronization error decreases from $1.96\times {10}^{-3}$ to $1.30\times {10}^{-3}$. In addition, the average algorithm runtime decreases from $0.82\mathrm{ms}$ to $0.63\mathrm{ms}$.