Although great progress has been made in a century-long effort to design and implement robotic exoskeletons, many design challenges continue to limit the performance of the system. One of the limiting factors is the lack of simple and effective control systems for the exoskeleton [56,137]. The position error caused by gravitational torques can be reduced by introducing an integral component to the PD control. In order to assure asymptotic stability, several components were previously added to the classic linear PID controllers, for example, fourth-order filter [101], nonlinear derivative term [4], nonlinear integral term (saturated function) [71], input saturation, and nonlinear observer [2].
Linear PID is the simplest and the most popular industrial controller, since tuning its internal parameters does not require a model of the plant and can be performed experimentally. Lyapunov function was previously used for the tuning procedure of a linear PID [72]. However, the inertia matrix and the gravitational torque vector of the system have to be clearly defined [63,73]. If the robot dynamic can be rewritten into a decoupled linear system with bounded nonlinear system, the stability of linear PID can be proven [117]. The asymptotic stability was not achieved.
In this chapter, the semiglobal asymptotic stability is proven along with a new approach for tuning the parameters of the PID controller. We apply this method on an upper limb exoskeleton. Experimental results show that this new PID tuning method is simple, systematic, and effective for robot control.
Semiglobal asymptotic stability; PID gains; Systematic tuning
The dynamics of a serial n-link exoskeleton robot can be written as [131]
M(q)⋅⋅q+C(q,⋅q)⋅q+g(q)+f(⋅q)=τ
where q∈ℜn denotes the joint positions, ⋅q∈ℜn denotes the joint velocities, M(q)∈ℜn×n is the inertia matrix, C(q,⋅q)∈ℜn×n is the centripetal and Coriolis matrix, f∈Rn is the frictional terms (Coulomb friction), τ∈ℜn is the input control vector, and g(q)∈ℜn is the gravity vector, which satisfies
g(q)=∂∂qU(q)U=∑ni=1mighi
where hi=yi, yi is in the vector oi=[xi,yi,zi]T, oi is given by the first three elements of the fourth column of the homogeneous transformation matrix.
The robot (2.1) has the following structural properties, which will be used in the stability analysis of the PID control.
Property 2.1. The inertia matrix is symmetric and positive definite, i.e.,
m1‖x‖2⩽xTMx⩽m2‖x‖2
where ∀x∈Rn, m1 and m2 are known positive scalar constant, and ‖.‖ denotes the Euclidean vector norm.
Property 2.2. The centripetal and Coriolis matrix is skew-symmetric, i.e.,
xT[⋅M(q)−2C(q,⋅q)]x=0
‖C(q,˙q)˙q‖⩽kc‖˙q‖2,kc>0
˙M(q)=C(q,˙q)+C(q,˙q)T
where Ck,ij(q)=(∂Bij∂qk+∂Bik∂qj−∂Bjk∂qi), kc=12maxq∈Rnn∑k=1‖Ck(q)‖, and C0(q) is a bounded matrix.
Property 2.3. The gravitational torques vector g(q) in (2.2) is Lipschitz:
‖g(x)−g(y)‖⩽kg‖x−y‖
The classic industrial PD law for the robot (2.1) is
τ=−Kp(q−qd)−Kd(⋅q−⋅qd)=PD1
where Kp and Kd are positive definite, symmetric, and constant matrices, which correspond to proportional and derivative coefficients, qd∈ℜn is the desired joint position, ⋅qd∈ℜn is the desired joint velocity. In regulation case, the desired position is constant, ⋅qd=0. We use the Lyapunov function candidate as
VPD=12˙qTM˙q+12˜qTKp˜q
where ˜q=q−qd. By the property ˙qT[⋅M(q)−2C(q,⋅q)]˙q=0 and the matrix inequality [159]
XTY+YTX⩽XTΛX+YTΛ−1Y,
which is valid for any X, Y∈Rn×m and any 0<Λ=ΛT∈Rn×n, the modeling error ˙qT(G+F) can be estimated as
˙qT(G+F)⩽˙qTK1˙q+(G+F)TK−11(G+F)
where K1 is any positive definite matrix, the derivative of (2.8) is
⋅VPD=−˙qTKd˙q+˙qT(G+F)⩽−˙qT(Kd−K1)˙q+ˉd
where (g+f)TK−11(g+f)⩽ˉd, ˉd can be regarded as upper bound of G+F.
⋅VPD⩽−˙qT(Kd−K1)˙q
τ=−Kp(q−qd)−Kd(⋅q−⋅qd)+F+G
⋅VPD⩽−˙qT(Kd−K1)˙q
In tracking the case, the purpose is to make the joint motors follow the desired positions. The desired joint positions are generated by the path planning or trajectory planning, and are sent to the joint motors [72]. The tracking control can be divided into several regulations by the path planning. We can also use the following auxiliary error method. We define x1=q as the link position vector, x2=˙q as the link velocity vector. The tracking error is
‾x1=x1−xd1‾x2=˙x1−˙xd1ddt‾x1=‾x2
where xd1 is link position desired and xd2 is link velocity desired. The auxiliary error is defined as
r=‾x2+Λ‾x1
where Λ=ΛT>0. The PD control (2.7) becomes
τ=−Kvr
When the dynamics of the robot (2.1) are known, the PD control with the known model compensation is
τ=−Kvr−f+(G+F)
where f=M(Λ⋅‾x1−⋅⋅qd)+C(Λ‾x1−⋅qd). We use the Lyapunov function candidate as
V=12rTMr
From Property 2.2, rT[⋅M−2C]r=0,
⋅V=−rTKvr
Then r→0 when the dynamics of the robot are known.
⋅V⩽−rTKvr+ˉd
In general, the regulation error of the PD control law (2.7) is bounded in a ball with radius ˉd. The stability property is not enough for robot control. The steady-state error caused by gravity and friction may be big. The derived gain Kd has to be increased to decrease them. In this way the closed-loop system becomes slow. This big settling time does not allow us to increase Kd as we want. We use the stability property of PD control (2.7) to stabilize the open loop unstable robot (2.1). For any Kd>K1 (K1>0), the following closed-loop system is stable:
M(q)⋅⋅q+C(q,⋅q)⋅q+g(q)+f(⋅q)=PD1
when the robot dynamics contain the gravitational torques vector g(q). Gravity compensation is a popular method to modify the PD control (2.7). The new PD control is
τ=PD1+ˆg(q)
where g(q)=ˆg(q)+˜g(q), ˆg(q), and ˜g(q) are the gravity estimation and estimation error and in this case (2.9) become
⋅VPD⩽−˙qT(Kd−K1)˙q+ˉd1
where ˉd1 is the upper bound of (˜g+f), (˜g+f)TK−11(˜g+f)⩽ˉd1. Normally, ˉd1<<ˉd, because ˜g is the estimation error of the gravity. The closed-loop system (2.13) becomes
M(q)⋅⋅q+C(q,⋅q)⋅q+g(q)+f(⋅q)=PD1+ˆg(q)
Similar stability results as before can be obtained and only the upper bound of the gravity becomes smaller. The position control objective is to evaluate the torque applied to the joints so that the robot joint displacements tend asymptotically to constant desired joint positions. Given a desired constant position qd∈Rn, semiglobal asymptotic stability of robot control is to design the input torque τ in (2.1) to cause regulation error
˜q=qd−q
˜q→0 and ⋅˜q→0 when initial conditions are in arbitrary large domain of attraction. Classic linear PID law is
τ=Kp˜q+Ki∫t0˜q(τ)dτ+Kd⋅˜q
where Kp, Ki, and Kd are proportional, integral, and derivative gains of the PID controller, respectively. The common linear PID control does not include any component of the robot dynamics into its control law. In order to assure asymptotic stability of PID control, the simplest approach is to modify the linear PID into a nonlinear one. This chapter will work on the linear PID, which is the most popular industrial controller. In [117] the robot dynamic was rewritten in a decoupled linear system and bounded nonlinear system; this linear PID control could not guarantee asymptotic stability. Sufficient conditions of the linear PID in [72] were given via Lyapunov analysis. However, these conditions are not explicit; the PID gains could not be decided with these conditions directly, and a complex tuning procedure was needed [73]. Because ˙qd=0, ⋅˜q=−˙q, the PID control law can be expressed via the following equations:
τ=Kp˜q−Kd˙q+ξ˙ξ=Ki˜q,ξ(0)=ξ0
In matrix form, it is
ddt[ξ˜q⋅˜q]=[Ki˜q−˙q¨qd+M−1(C˙q+g−Kp˜q+Kd˙q−ξ)]
The closed-loop system of the robot (2.13) is
M(q)¨q+C(q,˙q)˙q+g(q)=Kp˜q−Kd˙q+ξ,˙ξ=Ki˜q
The equilibrium is [ξ,˜q,⋅˜q]=[ξ⁎,0,0]. Since at equilibrium point q=qd the equilibrium is [g(qd),0,0]. In order to move the equilibrium to origin, we define ˜ξ=ξ−g(qd). The closed-loop equation becomes
M(q)¨q+C(q,˙q)˙q+g(q)=Kp˜q−Kd˙q+˜ξ+g(qd)⋅˜ξ=Ki˜q
2.1.1 Stable PD control
2.1.2 Stable PID control
We use the following three important properties of robot PID control to derive a systematic tuning method:
The turning steps are shown in Fig. 2.1. Here, PD1 is a PD controller, PID2 is the PID controller after parameters tuning, PID3 is the PID controller after the parameters refining, and PID4 is the PID controller after stability criterion. The final PID controller is τ.
Since the robot dynamic is not stable in an open loop, it is impossible to send step commands to all joints of the robot to tune PID gains. We use the following closed-loop tuning method.
The PD control (2.14) cannot guarantee zero of the steady-state error. The integrator is the most effective tool to eliminate steady-state error. PD control (2.7) becomes PID control as
τ=Kp˜q+Ki∫t0˜q(τ)dτ+Kdd˜qdt=PID2
where Kp, Ki, and Kd are proportional, integral, and derivative gains of the PID controller, respectively. The integrator gain Ki has to be increased when the steady-state error is big. This causes big overshoot, long settling time, and is less robust. PD1 is defined in (2.7) as
PD1=−Kp(q−qd)−Kd(⋅q−⋅qd)
From (2.15), we know that any PD controller can guarantee stability (bounded) of any robot manipulator in the regulation case. The stability property assures us to find another PID controller for the closed-loop system as in Fig. 2.2A. The total control system is
τ=−Kp1(q−qd1)−Kd1(⋅q−⋅qd1)+ˆg(q)qd1=Kp2(q−qd)+Kd2(⋅q−⋅qd)Kp˜q+Ki∫t0(q−qd)dτ
However, the controller (2.30) loses the PID form. Another tuning method in the closed-loop is to change PD1 directly; see Fig. 2.2B. Although the closed-loop system is different when PD1 is changed, the stability is always guaranteed with (2.15) with the change of PD1. The introduction of an integrator may destroy the stability, and in the next section we will show how to assure stability with PID control. We use Fig. 2.2B to adjust PID gains such that we can tune the PID controllers one by one.
Since PD/PID control is linear, the change of PD1 is the same as adding another controller PID2 to PD1. From (2.9), we know that the closed-loop system with PD1 is stable. When we apply a PID2 control to the closed-loop system (2.13), it is
M(q)⋅⋅q+C(q,⋅q)⋅q+˜g(q)+f(⋅q)−PD1=PID2
A gravity compensation to the closed-loop system (2.13) is
M(q)⋅⋅q+C(q,⋅q)⋅q+g(q)+f(⋅q)−PD1=ˆg(q)
When we apply the PID control and the gravity compensation to the closed-loop system (2.31), it is
M(q)⋅⋅q+C(q,⋅q)⋅q+g(q)+f(⋅q)−PD1=PID2+ˆg(q)
The total control torque to the robot is
τ=PID2+PD1+ˆg(q)
From (2.31) to (2.34), we see that the control torque to the robot manipulator is linearly independent of the robot dynamic (2.1). In the general case, if we tune PID controllers m times, they can be expressed as
M(q)¨q+C(q,˙q)˙q+g(q)+f(⋅q)=m∑j=1PIDj+ˆg(q)
where
m∑j=1PIDj=m∑j=1Kp,j˜q+m∑j=1Ki,j∫t0˜q(τ)dτ+m∑j=1Kd,jd˜qdt
PD1 is a special PID with Ki=0. This property allows us to start a PID control with small gains such that the closed-loop system is stable. Then any other tuning rule can be applied to obtain new PID gains one by one. The final PID gains are the summation of all these controllers (gains).
Although the robot dynamics are strong nonlinear, the behaviors of the closed-loop system with PD/PID control are similar with the transient responses of a linear system. On the other hand, after PID control, each joint of the robot can be characterized as a single input–single output (SISO) system.
Several methods can be used to linearize the robot models. If the velocity and gravity are neglected, the terms C(q,˙q)˙q and g(q) in the nonlinear dynamics (2.1) are zero. The resulting system is a linear model [45]:
M(q)¨q=u
Obviously, it is an oversimplified model. Since the velocity dependent term C(q,˙q)˙q representing Coriolis-centrifugal forces, it is negligible for small joint velocities. A rate linearization scheme can be used as [44]
A¨q+Bq=u
where A=M(q)|q=q0, B=∂g(q)∂q|q=q0, q0 is an operating point. Many experiments show that even at low speeds, C(q,˙q) is not zero [127].
The velocity and gravity are main control issues of robots, and they are dominant components of the dynamics. When the robot model is completely known, Taylor series expansion can be applied [89]. At the operating point q0 the nonlinear model (2.1) can be approximated by
A¨q+D˙q+Bq=τ
where A=M(q)|q=q0, B=∂[g(q)+C(q,˙q)]∂q|q=q0, D=∂C(q,˙q)∂˙q|q=q0.
We use this identification-based linearization method. For each joint, the typical linear model is a first-order system with transportation delay as
Gp=Km1+Tmse−tms
The response is characterized by three parameters: the plant gain Km, the delay time tm, and the time constant Tm. These are found by drawing a tangent to the step response at its point of inflection and noting its intersections with the time axis and the steady state value.
Sometimes the first-order (2.39) model cannot describe the complete nonlinear dynamic of the robot. A reasonable linear model of the robot is a Taylor series model as in (2.38). The model can be written in the frequency domain:
qi(s)τi(s)=KmT2ms2+2ξmTms+1e−tms
or
qi(s)τi(s)=Km(1+Tm1s)(1+Tm2s)e−tms
The responses of this second-order model are similar with mechanical motions. If there exists a big overshoot a negative zero is added in (2.40)
qi(s)τi(s)=Km(1+Tm3s)(1+Tm1s)(1+Tm2s)e−tms
The normal input signals for the PID tuning are step and repeat inputs.
Because the robot can be approximated by a linear system, some tuning rules for linear systems can be applied for the closed-loop system tuning. We first give PD tuning rules. When each joint can be approximated by a first-order system,
Gp=Km1+Tmse−tms
Here, Km, Tm, and tm are obtained from Fig. 2.3.
The linear PID law in time domain (2.29) can be transformed into the frequency domain:
τ(s)=Kc(1+1Tis+Tds)E(s)=Gc(s)E(s)=PID2
Similar with Ziegler–Nichols [161] and Cohen–Coon [20] tuning methods, we use a heuristic method to tune a PID controller. For PD control, our tuning law is shown in Table 2.1. Here, we use the similar tuning formulas with Ziegler–Nichols. By several experiments, we found a=1 is good.
Table 2.1
Ziegler–Nichols and Cohen–Coon methods for PI/PD
Kc | Ti | Td | |
---|---|---|---|
Ziegler–Nichols tuning | aTmKmτm | 0.5τm | |
Cohen–Coon method | TmKmτm(43+τm4Tm) | 4Tmτm11Tm+2τm | |
Our Method | Tm2Km | T m1 |
If each joint is approximated by a second-order system,
qi(s)ui(s)=KmT2ms2+2ξmTms+1
The PD gains are tuned similarly with [58] and [24]; see Table 2.2.
Table 2.2
PD tuning for the second-order model
When PD control cannot provide good performances, PID control should be used. The PID gains for the first-order model is decided by Table 2.3.
Table 2.3
PID tuning for the first-order model
Kc | Ti | Td | |
---|---|---|---|
Ziegler–Nichols tuning | aTmKmτm, | 2τm | 0.5τm |
Cohen–Coon method | TmKmτmτm4Tm | τm(32Tm+6τm)13Tm+8τm | 4Tmτm11Tm+2τm |
Our Method | Tm2Km | T m2 | T m1 |
Here, Kc=Kp is a proportional gain, Ti=KcKi is a time constant, and Td=KdKc is a derivative time constant.
The PID gains for the second-order model is decided by Table 2.4.
Table 2.4
PID tuning for the second-order model
Kc | Ti | Td | |
---|---|---|---|
Method 1 | 5Tm1ξmKmTm3 | 2Tm1ξm | Tm1+0.1ξm0.8Tm1ξm |
Method 2 | Tm2Km | T m2 | T m1 |
Our Method | 20ξmTmKm | 15ξmTm | T2m10 |
From (2.35), we see the PID gains are linear independent, and we can modify them directly. The refinement of PID2 is the same as adding a new PID controller, PID3, into (2.34). We use Table 2.5 to refine PID gains.
Table 2.5
Refined PID (PID3)
Rise | Overshoot | Settling | Steady Error | Stability | |
---|---|---|---|---|---|
Kp↑ | Decrease | Increase | Small Increase | Decrease | Degrade |
Ki↑ | Small Decrease | Increase | Increase | Large Decrease | Degrade |
Kd↑ | Small Decrease | Decrease | Increase | Minor Decrease | Improve |
After we refine the process, the robot control is
τ=PD1+PID2+PID3+ˆg(q)
In order to decrease the steady-state error, we should increase Ki. In order to get less settling time, we should decrease Kd. In order to get less overshoot, we should decrease Kp. However, the above tuning process does not guarantee stability of the closed-loop system. In the next subsection, we will give the bounds of the PID gains to assure PID control is stable.
For the robot dynamic controlled by the PID controller (2.35), the closed-loop system (2.18) is semiglobally asymptotically stable at the equilibrium x=[ξ−g(qd),˜q,⋅˜q]T=0, provided that control gains satisfy (2.19). The three gain matrices of the linear PID control (2.35) can be chosen directly from the conditions (2.19). From (2.35), we know that the PID control with gravity compensation (2.42) is
τ=3∑j=1PIDj+ˆg(q)=PIDf+ˆg(q)
Now we apply the condition (2.19) to PIDf. If the gains of PIDf are not in the bound of (2.19), we add a new PID controller, PID4, such that the gains of PIDf+PID4 are in the bounds of (2.19). The final control torque to the robot is
τ=PD1+PID2+PID3+PID4+ˆg(q)
Table 2.6 gives a comparative analysis of the proposed method with other PID tuning methods.
Table 2.6
Comparison of the PID tuning method
PID tuning method | system | model | stability | systematic | adaptive |
---|---|---|---|---|---|
Our Method | linear/nonlinear | no | yes | yes | no |
Ziegler–Nichols [161] Cohen–Coon [20] |
linear | no | no | yes | no |
Model based [24,58] | linear/nonlinear | yes | no | no | yes |
Lyapunov method [21,22] | nonlinear | no | yes | no | no |
Frequency domain | linear | no | no | yes | no |
Optimization method [81] | linear | yes | no | no | no |
Adaptive tuning [143] | linear | yes | no | no | yes |
Intelligent method [85,129] | linear/nonlinear | no | no | no | yes |
Impedance method [21,56] | robot | yes | no | no | no |
Here, we compare our method with the other eight PID tuning algorithms in six properties. It can be seen that apart from adaptive ability, our method is better than the others for robot control.
The upper limb exoskeleton robot in UC-Santa Cruz is shown in Fig. 2.4. It has 7-DoF (degrees-of-freedom) as in Fig. 2.5. The computer control platform of this exoskeleton robot is a PC104 with an Intel [email protected] GHz processor and 512 Mb RAM. The motors for the first four joints are mounted in the base such that the large mass of the motors can be removed. Torque transmission from the motors to the joints is achieved using a cable system. The other three small motors are mounted in link five.
The real-time control program operated in Windows XP with Matlab 7.1, Windows Real-Time Target and C++. All of the controllers employed a sampling frequency of 1 kHz. The properties of the exoskeleton with respect to base frame are shown in Table 2.7.
Table 2.7
Parameters of the exoskeleton
Joint | Mass (kg) | Center (m) | Length (m) |
---|---|---|---|
1 | 3.4 | 0.3 | 0.7 |
2 | 1.7 | 0.05 | 0.1 |
3 | 0.7 | 0.1 | 0.2 |
4 | 1.2 | 0.02 | 0.05 |
5 | 1.8 | 0.02 | 0.05 |
6 | 0.2 | 0.04 | 0.1 |
7 | 0.5 | 0.02 | 0.05 |
We first use the following PD1 to stabilize the robot:
Kp1=diag[150,150,100,150,100,100,100]Kd1=diag[330,330,300,320,320,300,300]
The joint velocities are estimated by the standard filters:
˜˙q(s)=bss+aq(s)=18ss+30q(s)
Here, the main weight of the exoskeleton is in the first four joints. The potential energy is
U=m1gl1s1+m2g(l1s1+c2l2s1)+m3ga3s1s2+m4g[a4c4(c1s3+c2c3s1)+a4s4(c1c3−c2s1s3)+a3s1s2]
The gravity compensation in (2.18) is calculated by
ˆg=∂∂qU(q)
Then we use the step responses of linear systems to approximate the closed-loop responses of the robot via PD1. The step responses of the closed-loop systems of the robot and the linear systems are shown in Fig. 2.6, where in the dash lines are the step responses of the following second-order linear systems:
G1=0.9360s2+9s+1,G2=120s2+3s+1G3=0.95.5s2+4s+1,G4=0.8530s2+8s+1
In order to tuning the gains of the PID (2.29), this PID is rewritten as
PIDt=Kc(˜q+1Ti∫t0˜q(τ)dτ+Td⋅˜q)
where Kc=Kp is proportional gain, Ti=KcKi is integral time constant, and Td=KdKc is derivative time constant. We use the following tuning rule:
Kc=20ξmTmKm,Ti=15ξmTm,Td=T2m10
to tune the PID parameters. This rule is similar with [58] and [24], in their case Kc=5Tm1ξmKmTm3, Ti=2Tm1ξm, Td=Tm1+0.1ξm0.8Tm1ξm. It is different with the other two famous rules, Ziegler–Nichols and Cohen–Coon methods, where Kc=aTmKmτm, Ti=2τm, Td=0.5τm or Kc=TmKmτm(43+τm4Tm), Ti=τm(32Tm+6τm)13Tm+8τm, Td=4Tmτm11Tm+2τm. Because their rules are suitable for the process control, our rule is for mechanical systems. By the rule (2.45) the PID2 are
Kp2=diag[90,30,40,90,10,150,10]Ki2=diag[1,2,20,1.5,3,1,2]Kd2=diag[500,410,350,400,50,30,400]
The control torque becomes u=PID1+ˆg(q)+PID2. The control results of Joint 1 are shown in Fig. 2.7.
After this refine turning, PID3 is
Kp3=diag[5,4,5,6,3,4,2]Ki3=diag[32,28,21,25,21,21,22]Kd3=diag[5,4,4,10,6,10,10]
The final control is
PIDf=PD1+ˆg(q)+PID2+PID3
The stability condition (2.19) gives a sufficient condition for the minimal values of proportional and derivative gains and maximal values of integral gains. We find that the final control (2.48) satisfies the conditions (2.19). The final control results for Joint 3 and Joint 7 are shown in Fig. 2.8.
In this chapter the linear PID control for a class of exoskeleton robots is addressed. The conditions of the semiglobal asymptotic stability is very simple, and the linear PID control is exactly the same as the industrial controller. The systematic tuning method for PID control is proposed. This method can be applied to any robot manipulator. By using several properties of robot manipulators, the tuning process becomes simple and is easily applied in real applications. Some concepts for PID tuning are novel, such as step responses for the closed-loop systems under any PD control, and the joint torque is separated into several independent PID. We finally apply this method on an upper limb exoskeleton. Real experiment results give validation of our PID tuning method.
3.141.199.243