A method, system, medium, and apparatus for fault-tolerant control of redundant dual-arm robots based on quadratic programming

Abstract

The application discloses a redundancy dual-arm fault-tolerant control method and system based on quadratic programming, a medium and equipment, and the method comprises the following steps: constructing a redundancy dual-arm fault-tolerant model, modeling the motion problem of the dual arm under a given end trajectory; converting the dual-arm motion control problem with joint faults into a quadratic programming problem; solving the quadratic programming problem by using a time-varying parameter-based recurrent neural network solving method to obtain information of each joint of the dual arm; constructing a dynamic observer for real-time feedback of joint states and integrating the dynamic observer into a velocity observation function recurrent neural network solver; solving an optimal solution of the quadratic programming problem based on the velocity observation function recurrent neural network solver to drive the dual arm with joint faults to cooperatively complete a given expected task by using the remaining intact joints. The application simultaneously considers positioning of the fault joint and can efficiently and accurately process the motion planning problem of the dual arm.

Description

Technical Field

[0001] The present invention relates to the technical field of motion planning of redundant manipulators, and in particular to a fault-tolerant control method, system, medium and equipment for redundant dual manipulators based on quadratic programming. Background Art

[0002] A redundant robotic arm is a device with multiple degrees of freedom, offering exceptional flexibility and the ability to simultaneously perform various secondary tasks while simultaneously executing the primary end-effector task. As robotic arms gain popularity in many fields, their operating environments are becoming increasingly complex, making sudden joint failures an unavoidable problem. This is especially true in hazardous environments, where timely repair or replacement is often impossible. Consequently, the remaining healthy joints must continue to complete the given task.

[0003] Traditional robotic arm control methods are mainly designed for robotic arms with intact joints, which have certain limitations in actual use. In recent years, methods based on fault-tolerant control have been proposed and applied. However, the current fault-tolerant control can only ensure that the robotic arm can complete the given task when some joints fail, but it cannot accurately determine which joints have failed.

[0004] At the same time, compared with the work of a single robotic arm, the collaborative work of dual or multiple robotic arms can not only improve work efficiency, but also complete some tasks that are difficult for a single robotic arm to complete, such as moving objects, assembling components, and cooking food. Summary of the Invention

[0005] In order to overcome the defects and shortcomings of the existing technology, the present invention provides a fault-tolerant control method for redundant dual robotic arms based on quadratic programming. The present invention also takes into account the positioning of faulty joints and adopts neural dynamics for solution to achieve low computational complexity and can efficiently and accurately handle the motion planning problem of the robotic arm.

[0006] The second object of the present invention is to provide a fault-tolerant control system of redundant dual manipulators based on quadratic programming;

[0007] A third object of the present invention is to provide a computer-readable storage medium;

[0008] A fourth object of the present invention is to provide a computer device.

[0009] In order to achieve the above object, the present invention adopts the following technical solutions:

[0010] The present invention provides a fault-tolerant control method for redundant dual robotic arms based on quadratic programming, comprising the following steps:

[0011] A redundant dual-arm fault-tolerant model is constructed, and a motion problem of the dual-arm is modeled under a given end trajectory.

[0012] The motion control problem of the dual-arm with joint faults is converted into a quadratic programming problem.

[0013] A recursive neural network solving method based on time-varying parameters is used to solve the quadratic programming problem to obtain information of each joint of the dual-arm.

[0014] A dynamic observer for real-time feedback of joint states is constructed and integrated into a recursive neural network solver of a velocity observation function.

[0015] The recursive neural network solver of the velocity observation function is used to solve an optimal solution of the quadratic programming problem to drive the dual-arm with joint faults to complete a given desired task by using the remaining intact joints.

[0016] As a preferred technical solution, under a given end trajectory, a motion problem of the dual-arm is modeled, and the specific steps include:

[0017] The relationship between the end position of the dual-arm and each joint is represented as:

[0018] r L / R (t)=f L / R (θ L / R (t))

[0019] Wherein, θ L / R (t)∈R n represents a joint vector, r L / R (t)∈R m is an end position vector of the dual-arm, t represents working time, m is a Cartesian space dimension of the dual-arm, f L / R (·):R n →R m is a relationship between joint angles and the end position of the dual-arm, n represents a degree of freedom of the dual-arm, and L / R represents a left / right redundant dual-arm.

[0020] After derivation, the following is obtained:

[0021]

[0022] Wherein, is a Jacobian matrix.

[0023] The fault model of the joint is:

[0024]

[0025] Wherein, a∈[1,2,...,n] and b∈[1,2,...,n] represent joints with faults, [tf1 , t f2 ,..., t fa ] and [t f1 , t f2 ,..., t fb ] represent the instantaneous time of joint [L,1, L,2,..., L,a] and joint [L,1, L,2,..., L,b] failure, respectively;

[0026] The joint failure model establishes a speed compensation mechanism, and the compensation amount expression of the joint speed of the left robot arm is:

[0027]

[0028] wherein, J L -1 is the pseudo-inverse of the Jacobian matrix of the left robot arm, j L,a is the a-th column in the Jacobian matrix of the left robot arm;

[0029] The compensation amount expression of the joint speed of the right robot arm is:

[0030]

[0031] wherein, -1 is the pseudo-inverse of the Jacobian matrix of the right robot arm, j R,b is the b-th column in the Jacobian matrix of the left robot arm.

[0032] As a preferred technical solution, the motion control problem of the dual robot arm with joint failure is converted into a quadratic programming problem, which specifically includes:

[0033] The quadratic programming form of the left robot arm with joint fault tolerance control is:

[0034]

[0035] wherein, represents the repetitive motion optimization criterion for overcoming the left robot arm joint angle drift phenomenon when the robot performs repetitive tasks, I is a unit matrix, θ L (0) is the initial position of the left robot arm joint, represents the left robot arm joint speed, φ L represents the compensation amount of the left robot arm joint speed, h L : = l L (θ L (t) - θ L (0)), l L > 0 is a parameter for adjusting the convergence speed, represents the fault tolerance set of the left robot arm joint speed;

[0036] The quadratic programming form of the right robot arm with joint fault-tolerant control is represented as:

[0037]

[0038] wherein, represents a repetitive motion optimization criterion for overcoming the phenomenon of right robot arm joint angle drift when the robot performs repetitive tasks, R (0) is the initial position of the right robot arm joint, represents the right robot arm joint velocity, φ R represents the compensation amount of the joint velocity of the right robot arm, h R : = l R (θ R (t)-θ R (t)), l R > 0 is a parameter for adjusting the convergence speed, represents a fault-tolerant set of right robot arm joint velocity;

[0039] The quadratic programming problems of the left and right robot arms are converted into a unified quadratic programming problem based on fault-tolerant control, represented as:

[0040]

[0041] wherein, ξ = [ψ L ; ψ R ] ∈ R 2n , Λ = [M L , 0; 0, M R ] ∈ R 2n×2n , q = [h L ; h R ] ∈ R 2n , G = [J L , 0; 0, J R ] ∈ R 2m×2n , Ω = [Ω L ; Ω R ], m is the Cartesian space dimension of the robot arm, and n represents the degree of freedom of the robot arm.

[0042] As a preferred technical solution, a recursive neural network based on time-varying parameters is used to solve the quadratic programming problem to obtain information of each joint of the robot arm, specifically including:

[0043] The error function between the target value and the actual value is constructed as:

[0044]

[0045] wherein, B = [Λ, G T ; G, 0] ∈ R2(n+m)×2(n+m) , k = [-q; c] e R 2(n+m) ;

[0046] The time-varying neural network model is constructed, and the derivative of the time-varying error function is represented as:

[0047] dδ(t) / dt = -ηe t Ψ(δ(t))

[0048] Wherein, η>0 is a parameter for adjusting the convergence rate, and Ψ(·) is an array composed of an activation function constructed in a linear and monotonically increasing manner: Ξ(x) = x;

[0049] The time-varying convergence neural network model is represented in an implicit dynamic form as:

[0050]

[0051] Wherein, ηe t The activation function Ψ(·) is a monotonically increasing odd function varying with time t;

[0052] The intermediate variable is constructed to estimate the joint speed, and is specifically represented as:

[0053]

[0054] Wherein, Respectively, the estimated value of K is represented as:

[0055]

[0056] Wherein,

[0057] The recursive neural network solver based on the speed observation function is represented as:

[0058]

[0059] As a preferred technical solution, a dynamic observer for real-time feedback of joint state is constructed, and is specifically represented as:

[0060]

[0061] Wherein, λ1 and λ2 are convergence scale parameters, is an error term, The estimated value of K is represented.

[0062] In order to achieve the above-mentioned second purpose, the technical scheme adopted by the present application is as follows:

[0063] ​The application discloses a redundancy dual-robot arm fault-tolerant control system based on quadratic programming.

[0064] The redundancy dual-robot arm fault-tolerant model construction module is used for constructing a redundancy dual-robot arm fault-tolerant model, and modeling a motion problem of the robot arm under a given end trajectory.

[0065] The quadratic programming problem conversion module is used for converting a dual-robot arm motion control problem with joint faults into a quadratic programming problem.

[0066] The solving module is used for solving the quadratic programming problem by adopting a time-varying parameter-based recurrent neural network solving method, so as to obtain information of each joint of the robot arm.

[0067] The dynamic observer construction module is used for constructing a dynamic observer for real-time feedback of joint states, and integrating into a velocity observation function recurrent neural network solver.

[0068] The optimal solution solving module is used for solving an optimal solution of the quadratic programming problem based on the velocity observation function recurrent neural network solver, so as to drive the robot arm with joint faults to complete a given expected task by utilizing the remaining intact joints.

[0069] In order to achieve the third purpose, the application adopts the following technical scheme.

[0070] A computer readable storage medium stores a program, and the program is executed by a processor to implement the fault-tolerant control method of the redundancy dual-robot arm based on quadratic programming.

[0071] In order to achieve the fourth purpose, the application adopts the following technical scheme.

[0072] A computer device includes a processor and a memory for storing a program executable by the processor, and the processor executes the program stored in the memory to implement the fault-tolerant control method of the redundancy dual-robot arm based on quadratic programming.

[0073] Compared with the prior art, the application has the following advantages and beneficial effects.

[0074] (1) The application adopts a time-varying parameter neural dynamics design method, solves the problem that a fixed parameter neural network is difficult to solve a time-varying robot kinematics problem online, and achieves the technical effect of solving a time-varying robot fault-tolerant control online.

[0075] (2) The joint state observer is constructed, the specific position of the joint fault of the mechanical arm is difficult to determine by the previous fault-tolerant method, and the technical effect of providing a basis for the later maintenance of the mechanical arm is achieved.

[0076] (3) The neural dynamics method is adopted as the control framework, the shortcomings that the traditional control scheme cannot perform parallel computing and efficiently process task targets are solved, the error of the end effector can converge faster, and the technical effects of high precision and high speed control requirements are achieved. BRIEF DESCRIPTION OF DRAWINGS

[0077] Figure 1 The flowchart of the redundancy dual-arm fault-tolerant control method based on quadratic programming of the application is shown. DETAILED DESCRIPTION

[0078] In order to make the purpose, technical scheme and advantages of the application more clear and explicit, the application will be further described in detail below in combination with the drawings and examples. It should be understood that the specific examples described herein are only used to explain the application, and are not used to limit the application.

[0079] Example 1

[0080] As shown in the figure, the embodiment provides a redundancy dual-arm fault-tolerant control method based on quadratic programming, which comprises the following steps: Figure 1

[0081] S1: A redundancy dual-arm fault-tolerant model is constructed, and the motion problem of the mechanical arm is modeled under the given end trajectory;

[0082] The specific implementation steps of step S1 are: based on the given redundancy dual-arm model, the relationship between the end position of the mechanical arm and each joint is specifically represented as:

[0083] r L / R (t)=f L / R (θ L / R (t)) (1)

[0084] Wherein, θ L / R (t)∈R n represents the joint vector, r L / R (t)∈R m is the end position vector of the mechanical arm, t represents the working time, m is the Cartesian space dimension of the mechanical arm, f L / R (·):R n →R m is the relationship between the joint angle of the mechanical arm and the end position, n represents the degree of freedom of the mechanical arm, L / R represents the left / right redundant mechanical arm;

[0085] The derivative of formula (1) can be obtained:​

[0086]

[0087] wherein, is the Jacobian matrix;

[0088] For time instant t > t f , the failure of joint i is usually modeled as Based on this, the failure model of joint is:

[0089]

[0090] wherein, a ∈ [1, 2, …, n] and b ∈ [1, 2, …, n] represent the joints with failure, [t f1 , t f2 , …, t fa ] and [t f1 , t f2 , …, t fb ] represent the time instants of joint [L, 1, L, 2, …, L, a] and joint [L, 1, L, 2, …, L, b] failure, respectively;

[0091] And a velocity compensation mechanism is established for the joint failure model (3), taking the left robot arm as an example:

[0092] Firstly, define j L,a as the a-th column in the Jacobian matrix of the left robot arm: J L = [j L,1 , j L,2 , …j L,a-1 , j L,a , j L,a+1 …j L,n ], each column represents the contribution of joint speed to the end effector speed, assuming that a certain joint fails to lock, it no longer provides speed for the end, the corresponding degenerate Jacobian matrix is: J' L = [j L,1 , j L,2 , …j L,a-1 , 0, j L,a+1 …j L,n ], according to the concept of perturbation model, the change of joint speed and end effector speed is:

[0093]

[0094] wherein, ΔJ L = J' L - J L is the perturbation Jacobian matrix after joint failure, is the end effector speed jump before velocity compensation, and respectively represent joint velocity and the velocity variation of joint after joint failure;

[0095] To minimize the end-effector velocity jump The joint velocity compensation is expressed as:

[0096]

[0097] where is the end-effector velocity jump value after joint velocity compensation, φ L is the compensation of joint velocity;

[0098] According to the definition of J' L , we can get Then the end-effector velocity jump value expression is:

[0099]

[0100] Take The compensation of joint velocity expression is:

[0101]

[0102] where J" L is the pseudo-inverse of Jacobian matrix;

[0103] Similar to the modeling of the left robot arm, the compensation of joint velocity expression of the right robot arm is:

[0104]

[0105] where the meanings of parameters are the same as the left robot arm;

[0106] S2: Convert the dual robot arm motion control problem with joint failure in step S1 into a quadratic programming problem;

[0107] The specific implementation steps of step S2 are as follows: first, based on the target problem, the quadratic programming form of the left robot arm with joint fault-tolerant control can be described as:

[0108]

[0109] where represents the repetitive motion optimization criterion used to overcome the joint angle drift phenomenon when the robot performs repetitive tasks, I is the unit matrix, θ L (0) is the initial position of the robot arm joint, h L : = l L (θ L (t) - θ L (0)), l L > 0 is a parameter for adjusting the convergence speed, a set of fault-tolerant joints;

[0110] The quadratic programming form of the right robot arm with joint fault-tolerant control can be described as:

[0111]

[0112] where ψ R , M R , h R , Ω R are the same as those of the left robot arm;

[0113] Then, the above respective quadratic programming problems of the left and right robot arms are converted into a unified quadratic programming problem based on fault-tolerant control, which can be expressed as:

[0114]

[0115] where the matrix and vector are defined as ξ=[ψ L ; ψ R ]∈R 2n , Λ=[M L , 0; 0, M R ]∈R 2n×2n , q=[h L ; h R ]∈R 2n , G=[J L , 0; 0, J R ]∈R 2m×2n , Ω=[Ω L ; Ω R ].

[0116] S3: After obtaining the quadratic programming problem (11) in step S2, a time-varying parameter-based recurrent neural network solving method is used to solve this quadratic programming problem in real time;

[0117] The specific implementation steps of step S3 are as follows: first, define the error function, i.e., the error function between the target value and the actual value:

[0118]

[0119] where B=[Λ, G T ; G, 0]∈R 2(n+m)×2(n+m) , κ=[-q; c]∈R 2(n+m) ; suppose that the above formula has a unique theoretical solution x(t)=x * (t), if the error function δ(t) converges to zero, i.e., the actual value can converge to the target value, then the unique theoretical solution x *(t), in order to ensure the convergence of error function δ(t), its time derivative is negative definite;

[0120] Thus, according to the neural dynamic design method, a time-varying neural network model is constructed in combination with the time-varying characteristics of the hardware system, and the derivative of the time-varying error function is represented as:

[0121] dδ(t) / dt=-ηe t Ψ(δ(t)) (13)

[0122] where η>0 is a parameter for adjusting the convergence rate, and Ψ(·) is an array composed of an activation function constructed in a linear monotonically increasing manner: Ξ(x)=x;

[0123] Based on equation (13), the time-varying convergent neural network model is represented in an implicit dynamic form as:

[0124]

[0125] where ηe t The activation function Ψ(·) is a monotonically increasing odd function varying with time t, and various types correspond to different mapping functions, such as linear-type, sigmoid-type, power-type and power-sigmoid-type activation functions, etc. The above formula (14) is a variable-parameter recurrent neural network solver;

[0126] Next, an intermediate variable is constructed to estimate the joint speed as follows:

[0127]

[0128] where is an estimate of , and the value of K is selected as:

[0129]

[0130] where

[0131] Suppose that a joint (for example, the k L,i th joint) is locked at a specific time instant, k L,i will become 0. Otherwise, if the k L,i th joint is working normally, k L,i ≠0 holds.

[0132] Therefore, the recurrent neural network solver based on the speed observation function is represented as:

[0133]

[0134] By calculating kL / R The value of the formula (17) can be detected during the task execution process, which joint fails, and the formula (17) is a recursive neural network solver with joint detection;

[0135] S4: After obtaining the recursive neural network solver in step S3, a dynamic observer for real-time feedback of joint state is constructed for redundancy resolution;

[0136] The specific implementation steps of step S4 are: the dynamic observer is represented by the following differential equation, which has the following form:

[0137]

[0138] Where λ1 and λ2 are convergence scale parameters, is an error term, represents the estimated value of K.

[0139] S5: The recursive neural network solver based on the speed observation function is used to solve the quadratic programming problem based on fault-tolerant control obtained in step S2. Specifically, the motion control problem of the robot arm is converted into a quadratic programming problem, and then a neural network is used to solve the optimal solution of the quadratic programming, so that the dual robot arm with joint failure can be controlled to complete the given expected task by using the remaining intact joints.

[0140] Embodiment 2

[0141] The embodiment provides a fault-tolerant control system for a redundant dual robot arm based on quadratic programming, which is used to realize the fault-tolerant control method for a redundant dual robot arm based on quadratic programming in the above embodiment 1. The system comprises a redundant dual robot arm fault-tolerant model construction module, a quadratic programming problem conversion module, a solving module, a dynamic observer construction module, and an optimal solution solving module.

[0142] In this embodiment, the redundant dual robot arm fault-tolerant model construction module is used to construct a redundant dual robot arm fault-tolerant model, and the motion problem of the robot arm is modeled under a given end trajectory.

[0143] In this embodiment, the quadratic programming problem conversion module is used to convert the motion control problem of the dual robot arm with joint failure into a quadratic programming problem.

[0144] In this embodiment, the solving module is used to solve the quadratic programming problem by using a recursive neural network solving method based on time-varying parameters to obtain information of each joint of the robot arm.

[0145] In this embodiment, the dynamic observer construction module is used to construct a dynamic observer for real-time feedback of joint state, and integrate it into the recursive neural network solver of the speed observation function.

[0146] In the embodiment, the optimal solution solving module is configured to solve the optimal solution of the quadratic programming problem based on a recurrent neural network solver of a speed observation function to drive the robot arm with joint faults to complete a given desired task in cooperation with the remaining intact joints.

[0147] Embodiment 3

[0148] The embodiment provides a storage medium, which can be a ROM, a RAM, a magnetic disk, an optical disk or the like storage medium, and the storage medium stores one or more programs, and the programs are executed by a processor to implement the fault-tolerant control method for a redundant dual robot arm based on a quadratic programming of the embodiment 1.

[0149] Embodiment 4

[0150] The embodiment provides a computing device, which can be a desktop computer, a notebook computer, a smart phone, a PDA handheld terminal, a tablet computer or other terminal device with a display function, and the computing device comprises a processor and a memory, the memory stores one or more programs, and the processor executes the programs stored in the memory to implement the fault-tolerant control method for a redundant dual robot arm based on a quadratic programming of the embodiment 1.

[0151] The above embodiments are the preferred embodiments of the present application, but the embodiments of the present application are not limited to the above embodiments, and any changes, modifications, substitutions, combinations and simplifications made without departing from the spirit and principle of the present application shall be equivalent replacement modes and shall be included in the protection scope of the present application.

Claims

1. A method for fault-tolerant control of redundant dual-arm robots based on quadratic programming, characterized in that, Comprising the following steps: A redundant dual-arm fault-tolerant model is constructed, and the motion problem of the dual-arm is modeled under a given end trajectory; The dual-arm motion control problem with joint faults is converted into a quadratic programming problem, which specifically includes: The quadratic programming form of the left arm with joint fault-tolerant control is expressed as: wherein represents a repetitive motion optimization criterion for overcoming the left robot arm joint angle drift phenomenon when the robot performs repetitive tasks, I is the identity matrix, θ L (0) is the initial position of the left robot arm joint, represents the left robot arm joint velocity, Ф L represents the compensation of the left robot arm joint velocity, h L : = l L (θ L (t) - θ L (0)), l L > 0 is a parameter that regulates the convergence speed, represents the fault-tolerant set of the left robot arm joint velocity; The quadratic programming form of the right arm with joint fault-tolerant control is expressed as: wherein, represents a repetitive motion optimization criterion for overcoming the right robot arm joint angle drift phenomenon when the robot performs repetitive tasks, θ R (0) is the initial position of the right robot arm joint, represents the right robot arm joint velocity, Ф R represents the compensation amount of the right robot arm joint velocity, h R : = l R (θ R (t) - θ R (t)), l R > 0 is a parameter for adjusting the convergence speed, represents the fault-tolerant set of the right robot arm joint velocity; The quadratic programming problems of the left and right arms are converted into a unified quadratic programming problem based on fault-tolerant control, which is expressed as: s.t.Gξ=c wherein ξ = [ψ L ; ψ R ] ∈ R 2n , Λ = [M L , 0; 0, M R ] ∈ R 2n×2n , q = [h L ; h R ] ∈ R 2n , G = [J L , 0; 0, J R ] ∈ R 2m×2n , Ω = [Ω L ; Ω R ], m is the Cartesian space dimension of the robot arm, and n represents the degrees of freedom of the robot arm. A time-varying parameter-based recurrent neural network solving method is used to solve the quadratic programming problem to obtain information of each joint of the dual-arm; A dynamic observer for real-time feedback of joint states is constructed and integrated into the velocity observation function-based recurrent neural network solver; The optimal solution of the quadratic programming problem is solved based on the velocity observation function-based recurrent neural network solver to drive the dual-arm with joint faults to complete the given desired task cooperatively using the remaining intact joints.

2. The SQP-based fault-tolerant control method of redundancy dual-arm robots according to claim 1, wherein, Under a given end trajectory, the motion problem of the dual-arm is modeled, and the specific steps include: The relationship between the end position of the dual-arm and each joint is expressed as: r L / R (t) = f L / R (θ L / R (t)) where θ L / R (t)∈R n represents the joint vector, r L / R (t)∈R m is the end position vector of the robot arm, t represents the working time, m is the Cartesian space dimension of the robot arm, f L / R (·):R n →R m is the relationship between the joint angle and the end position of the robot arm, n represents the degree of freedom of the robot arm, and L / R represents the left / right redundant robot arm. After derivation, the following is obtained: wherein is the Jacobian matrix; The joint fault model is: where a e [1, 2,..., n] and b e [1, 2,..., n] represent the joints with faults, [t f1 , t f2 ,..., t fa ] and [t f1 , t f2 ,..., t fb ] represent the time instants of the failure of the joints [L,1, L,2,..., L,a] and [L,1, L,2,..., L,b], respectively; The joint fault model establishes a velocity compensation mechanism, and the compensation amount expression of the joint velocity of the left arm is: where J L is the pseudo-inverse of the left manipulator Jacobian matrix, j L,a is the a-th column of the left manipulator Jacobian matrix; The compensation amount expression of the joint velocity of the right arm is: wherein, is the pseudo-inverse of the right arm Jacobian matrix, j R,b is the bth column of the left arm Jacobian matrix.

3. The SQP-based fault-tolerant control method of redundancy dual-arm robots according to claim 1, wherein, A time-varying parameter-based recurrent neural network solving method is used to solve the quadratic programming problem to obtain information of each joint of the dual-arm, which specifically includes: An error function between the target value and the actual value is constructed as: where B = [Λ, G T ; G, 0] e R 2(n+m)×2(n+m) , κ = [-q; c] e R 2(n+m) ; A time-varying neural network model is constructed, and the derivative of the time-varying error function is expressed as: dδ(t) / dt = -ηe t Ψ(δ(t)) where η>0 is a parameter for adjusting the convergence rate, and Ψ(·) is an activation function; The time-varying convergence neural network model is expressed in an implicit dynamic form as: wherein ηe t The activation function Ψ(·) is a monotonically increasing odd function varying with time t; An intermediate variable is constructed to estimate the joint velocity, which is specifically expressed as: wherein respectively the estimate of K is given by: wherein, The velocity observation function-based recurrent neural network solver is expressed as:

4. The SQP-based fault-tolerant control method of redundancy dual-arm robots according to claim 3, wherein, A dynamic observer for real-time feedback of joint states is constructed, which is specifically expressed as: where λ1and λ2are convergence scale parameters, is an error term, denotes an estimate of the value of K.

5. A twice-differentiable redundancy dual-arm fault-tolerant control system based on quadratic programming, characterized by, A system for implementing the quadratic programming-based fault-tolerant control method of the redundant dual-arm according to any one of claims 1-4, the system comprising: a redundant dual-arm fault-tolerant model construction module, a quadratic programming problem conversion module, a solving module, a dynamic observer construction module, and an optimal solution solving module; The redundant dual-arm fault-tolerant model construction module is used to construct a redundant dual-arm fault-tolerant model, and the motion problem of the dual-arm is modeled under a given end trajectory; The quadratic programming problem conversion module is used to convert the dual-arm motion control problem with joint faults into a quadratic programming problem; The solving module is used to use a time-varying parameter-based recurrent neural network solving method to solve the quadratic programming problem to obtain information of each joint of the dual-arm; The dynamic observer construction module is used to construct a dynamic observer for real-time feedback of joint states and integrate it into the velocity observation function-based recurrent neural network solver; The optimal solution solving module is used to solve the optimal solution of the quadratic programming problem based on the velocity observation function-based recurrent neural network solver to drive the dual-arm with joint faults to complete the given desired task cooperatively using the remaining intact joints. The optimal solution solving module is configured to solve the optimal solution of the quadratic programming problem based on a recurrent neural network solver of a velocity observation function, so as to drive the robot arm with joint faults to cooperatively complete a given desired task by using the remaining intact joints.

6. A computer-readable storage medium storing a program, characterized in that: The program is executed by the processor to implement the fault-tolerant control method of the dual redundant robot arm based on the quadratic programming according to any one of claims 1-4.

7. A computer device comprising a processor and a memory for storing a processor executable program, characterized in that, The processor executes the program stored in the memory to implement the fault-tolerant control method of the dual redundant robot arm based on the quadratic programming according to any one of claims 1-4.

Images