Stability of Nonlinear Systems Using Optimal Fuzzy Controllers and Its Simulation by Java Programming

Ⅰ. INTRODUCTION

Recently, the internet technologies such as Java Applets have been widely used for designing simulation programs for complicated systems. In [1], the simulation of fuzzy control for an inverted pendulum system based on Java Applets is presented. Mahmoodabadi et al. [2] applied Java programming to internet-based explanation of state feedback control for dynamic systems, e.g., the inverted pendulum and ball-beam system.

On the other hand, the development of high-performance controllers for various complex problems has been a major research topic among the control engineering practitioners in recent years. For example, Liu et al [3]. proposed a type-2 fuzzy switching control system for biped robots. Tseng et al. [4] designed a robust fuzzy controller for nonlinear discrete-time systems with persistent bounded disturbances. Huang et al. [5] designed and implemented a fuzzy controller for a two-wheel inverted pendulum system. Zhu [6] applied a fuzzy optimal controller for multistage fuzzy systems. Wang et al. [7] proposed an adaptive fuzzy backstepping controller for a class of nonlinear systems with sampled and delayed measurements.

In this way, synthesis of control policies has been presented as optimization problems of certain performance measures of the controlled systems. A very effective method of solving such optimum controller design problems is evolutionary algorithms. Yi et al. [8] applied single input rule modules dynamically connected fuzzy inference models for stabilizing a double inverted pendulum system and tuned parameters by a random optimization method. Shook et al. [9] used the genetic algorithm to optimize fuzzy logic controllers which were designed to manage two dampers for mitigation of seismic loads. The membership functions of multi-stage fuzzy load frequency control were automatically designed by the particle swarm optimization in [10]. A 2DOF planer robot has been controlled by the fuzzy logic controller and the particle swarm optimization has been utilized to tune fuzzy parameters in [11].

However, the design criteria (objective functions) of these practical engineering problems may conflict with each other so that improving one of them will deteriorate another. This inherent conflicting behavior of such objective functions leads to a set of optimal solutions named Pareto. This type of problems can be solved by using the multi-objective evolutionary algorithms. For instance, Ahmadi et al. [12] applied a new multi-objective uniform-diversity genetic algorithm with a diversity preserving mechanism to optimize a robust reliability-based controller with probabilistic uncertainties. Mahmoodabadi et al. [13] used and multi-objective particle swarm optimization for optimum design of fuzzy controllers for nonlinear systems.

One of the modern heuristic algorithms is particle swarm optimization (PSO) introduced by Kennedy and Eberhart [14], which is developed through simulation of simplified social systems and is robust for solving nonlinear optimization problems [15]. The PSO technique can generate a high quality solution with less calculation time and a more stable convergence characteristic in comparison with other evolutionary algorithms [16]. These advantages make PSO widely used in many engineering applications. In the recent years, several state-of-the-art PSO variants have been proposed, such as those in [17]-[23]. Furthermore, recently, several approaches, such as dynamic neighborhood PSO [24], dominated tree [25], Sigma method [26], vector evaluated PSO [27], dynamic multiple swarms [28], dynamic population size and adaptive local archives [29], etc., have been proposed to extend the PSO algorithm to deal with multi-objective optimization problems. This paper is aimed at improving multi-objective particle swarm optimization (MOPSO) by increasing the rate of convergence and diversity of solutions. The proposed MOPSO is applied to Pareto optimal fuzzy control design of a doubled inverted pendulum system. In the other words, by using the MOPSO algorithm, the important parameters of the single input rule modules dynamically connected fuzzy inference model are optimized in order to simultaneously decrease the distance error of the cart and summation errors of angles for the shorter and longer pendulums.

Ⅱ. BASIC CONCEPTS OF FUZZY CONTROLLER

Yubazaki et al. [30] originally proposed single input rule modules (SIRMs) dynamically connected fuzzy inference model for plural input fuzzy control. In this controller, for each input item (the states of the system), an SIRM and a dynamic importance degree (DID) are defined. DID consists of a base value that insures the role of the input item through a control process, and a dynamic value that changes with control situations to adjust DID. In the following, the concepts of the SIRM and DID are described.

Ⅲ. SIRM

Consider a dynamic system with $n$ input items and 1 output item. Since there are $n$ input items, $n$ SIRMs would be defined as

where $\mbox{SIRM}_i$ means the SIRM referred to the $i$th input item, and $R_i^j$ is the $j$th rule in the $\mbox{SIRM}_i$. $x_i$ corresponds to the variable in the antecedent part, and $u_i$ is the variable in the consequent part. $A_i^j$ and $C_i^j$ are the membership functions of the $x_i$ and $u_i$ in the $j$th rule of the $\mbox{SIRM}_i$, respectively. $j = 1,$ $2,$ $\ldots,$ $m$ is the index number of the rules in the $\mbox{SIRM}_i$. Here, the rules and membership functions for SIRMs to stabilize the double inverted pendulum system are from [8].

Ⅳ. DID

To express the different role of each input item in system performance, the dynamic importance degree $w_i^D$ for each input item $x_i$ $(i = 1, 2, \ldots, n)_{ }$ is defined as

where $w_i^0$ is a base value, $\Delta w_i^0$ is a fuzzy variable, and $B_i$ is a breadth for the $i$th input item ($i = 1, 2, \ldots, n)$. In this paper, the fuzzy variable $\Delta w_i^0$ of the inputs $x_i$ $(i = 1, 2, \ldots, n)$ to stabilize the double inverted pendulum system is completely similar to [8].

Once SIRMs and DID are determined, the driving force $F$ could be obtained by the following equation:

where $OSF$ is the output scaling factor, $u_i^0$ is the fuzzy inference result obtained from $\mbox{SIRM}_i$.

In this paper, the base values $w_i^0$ $(i = 1, 2, \ldots, n)$, the breadths $B_i$ $(i = 1, 2, \ldots, n)$, and the output scaling factor $OSF$ would be determined by using the multi-objective particle swarm optimization algorithm.

Ⅴ. DOUBLE INVERTED PENDULUM

In Fig. 1, the structure of a double inverted pendulum shows that the state vector $x = [x_1 , x_2 , x_3 , x_4 , x_5 , x_6 ]^{T} = [\alpha , \dot{\alpha},$ $\beta ,$ $\dot {\beta }, x, \dot {x}]^{T}$ includes the angle and angular velocity of the longer pendulum, the angle and angular velocity of the shorter pendulum, the position and velocity of the cart. The dynamical equations of the system are as follows:

Figure  1.  The structure of a double inverted pendulum system.

DownLoad: Full-Size Img PowerPoint

The masses of the cart, longer pendulum, and shorter pendulum are $M$, $m_1$ and $m_2$, respectively. $g$ represents the gravity acceleration. $l_1$ and $l_2$ are half length of the longer and shorter pendulums, respectively. The driving force applied horizontally to the cart is denoted as $F$. For simulation, the following specifications are used. $M = 1,$ $m_1 = 0.3\, \rm{kg},$ $m_2$ $= 0.1\, \rm{kg}$, $l_1 = 0.6\, \rm{m},$ $l_2 = 0.2\, \rm{m}$, and $g = 9.8\, \rm{m}/{\rm s}^2$. Furthermore, the initial and desired values are $x = [x_1 , x_2$, $x_3$, $x_4 , x_5 , x_6 ]^T = [{\pi}/{36}, 0, {\pi }/{36}, 0, 0, 0]^T$ and $x = [x_1, x_2,$ $x_3,$ $x_4, x_5, x_6]^T = [0, 0, 0, 0, 0, 0]^T$, respectively.

Ⅵ. BASIC CONCEPTS OF OPTIMIZATION

A Particle Swarm Optimization

Particle swam optimization is a population-based evolutionary algorithm where the candidate solutions are called particles and the position of each particle is changed via its own experience and its neighbors according to the following equations [31]$-$[34]:

where ${\pmb x}_i (t)$ and ${\pmb v}_i (t)$ denote the position and velocity of particle $i$, at time step $t$. $r_1 , r_2 \in [0, 1]$ are random values. $C_1$ are $C_2$ are the cognitive and social learning factors, respectively, and $W$ is the inertia weight. The personal best position of the particle $i$ is ${\pmb x}_{ \rm{ pbest}_i }$ and ${\pmb x}_ \rm{ gbest}$ is the position of the best particle of the entire swarm.

Experimental results illustrated that the linearly decreasing inertia weight over the iterations improves the performance of PSO [35]. Furthermore, it has shown that best solutions were determined when $C_1$ is linearly decreased and $C_2$ is linearly increased over the iterations [36]. Hence, the following linear formula for the inertia weight and learning factors are used.

where $W_1$ and $W_2$ are the initial and final values of the inertia weight, respectively. $C_{1i}$, $C_{2i}$, $C_{1f}$, and $C_{2f}$ are the initial and final values of the learning factors, respectively. $t$ is the current iteration number and $iter_{\max}$ is the maximum number of allowable iterations.

B Multi-objective Particle Swarm Optimization

In the following, the selection strategies of global best position and personal best position for the multi-objective PSO are described. Furthermore, a turbulence operator and a dynamic elimination method are introduced in order to enhance the solution searching ability of particles and to maintain the diversity of non-dominated solutions.

1) Selection of Global Best Position: A leader should be selected as ${\pmb x}_ \rm{gbest}$ for each particle in order to update its position. Here, a leader selection technique based on density measures is used. In fact, a neighborhood radius ($R_{ \rm{neighborhood}} )$ is considered for all non-dominated solutions. Two non-dominated solutions are neighbors if the Euclidean distance (measured in the objective domain) between them is less than $R_{ \rm{neighborhood}}$. Using this definition, the neighbors of all non-dominated solutions are calculated in the objective function domain, and the particle with fewer neighbors is considered as the leader.

2) Selection of Personal Best Position: The Sigma method proposed in [26] is applied to determining the personal best position of a particle. After assigning parameter $\sigma$ to all particles in the population and archive (10), particle $k$ in the archive would be selected as the personal best position for particle $i$ in the population, if the distance between $\sigma _i$ and $\sigma _k$ is minimum

where $f_1$ and $f_2$ are two objective functions of the considered particle.

3) Turbulence Operator In order to escape from local minima and find better solutions, a turbulence operator is used. $N$ particles from the population are randomly chosen to perform that according to the following equation:

where $rand$ is a random number which is generated uniformly in the interval [0, 1]. ${\pmb x}_{\max }$ and ${\pmb x}_{\min }$ are upper and lower bounds of the search space respectively. In this paper, $N =$ $P_m$ $\times$ number of particles, where $P_m$ is the probability of the turbulence operator.

4) Dynamic Elimination Technique: Elimination techniques are used to prune the archive and limit its size [37]$-$[40]; and here, the method introduced in [41] is applied. In this approach, for each particle in the archive, an elimination radius equal to $\varepsilon _ \rm{Dynamic}$ is defined. If the Euclidean distance (in the objective function space) between two particles is less than $\varepsilon _ \rm{Dynamic}$, then one of them will be eliminated [41].

5) Details of the Proposed Algorithm: Initially, the particles of the population should be randomly generated. Then, the inertia weight, the learning factors, and turbulence probability can be determined. In each iteration, the archive can be formed, and ${\pmb x} _{ \rm{pbest}_i }$ and ${\pmb x} _ \rm{gbest}$ are assigned. Then, for each particle, a random number $\rho \in [0, 1]$ will be considered. If a particle has $\rho <pro_ \rm{turb}$, where $pro_ \rm{turb}$ denotes turbulence probability, then a new particle will be produced by the turbulent operator. Other particles that are not selected for turbulent operation will be enhanced by PSO. This cycle should be repeated until the criterion of the maximum iteration is reached. The pseudo code of this algorithm is illustrated in Algorithm 1.

Algorithm 1 The pseudo code of MOPSO algorithm
Initialize population and the algorithm configuration of the proposed MOPSO.
For t= 1:itermax
Assign the inertia weight, the learning factors, and turbulence prob-ability;
Calculate the fitness values of all particles, update and prune thearchive with respect to εDynamic;
Determine xgbest(t);
For i= 1:population size
Determine xpbesti (t);
ρ= rand;
If ρ < proturb then update position xi(t) using turbulent operators.
Else update velocity and position xi(t) using PSO formulations.
End if
End for
End for.

 | Show Table

DownLoad: CSV

Ⅶ. PARETO DESIGN OF SIRMS DYNAMICALLY CONNECTED FUZZY CONTROLLER

In this section, Pareto design of SIRMs dynamically connected fuzzy controllers using the multi-objective particle swarm optimization is performed for the double inverted pendulum system. The distance error of the cart and the summation errors of angles for the shorter and longer pendulums are regarded as the objective functions that should be minimized simultaneously. The vector [$w^0_1$, $w^0_2$, $w^0_3$, $w^0_4$, $w^0_5$, $w^0_6$, $B_1$, $B_2$, $B_3$, $B_4$, $B_5$, $B_6$, $OSF$] is the vector of design variables where $w_i^0$ $(i = 1, 2, 3, 4, 5, 6)$, $B_i$ $(i = 1, 2, 3, 4, 5, 6)$, and $OSF$ are the base values, the breadths, and the output scaling factor, respectively. To compare the performance of the proposed method, two well-known versions of multi-objective optimization algorithms are used (Table Ⅰ). Also, the configuration of the MOPSO algorithm is as follows: population size = 100, $iter_{\max}$ $= 1000$, $W_1 = 0.9$, $W_1 = 0.4$, $C_{1i} = 2.5$, $C_{1f} = 0.5$, $C_{2i}$ $= 0.5$, $C_{2f} = 2.5$, $R_{ \rm{neighborhood}} = 0.02$, $P_m = 5/t$.

Table  Ⅰ.  THE PARAMETER CONFIGURATIONS OF THE USED MULTI-OBJECTIVE ALGORITHMS IN THE COMPARISON

Algorithm	Population size	Technique of the archive	Crossoverfunction(rate)	Mutation for pruning	Functionfunction(rate)	Reference evaluations
Sigma MOPSO	100	Clustering	-	Uniform (0.1)	100000	[26]
NSGAII	100	Crowding-distance	Scattered (0.8)	Uniform (0.1)	100000	[42]

 | Show Table

DownLoad: CSV

When the multi-objective optimization algorithms are applied to this problem, Pareto fronts will be achieved that are demonstrated in Fig. 2. In Fig. 2, Points $A$ and $C$ stand for the minimum distance error of the cart and the summation errors of angles for the shorter and longer pendulums, respectively.

Figure  2.  The suggested optimum point by [8] and the obtained Pareto fronts by using of Sigma method [26], NSGAII [42], and proposed method for optimal design of SIRMs dynamically connected fuzzy controllers.

DownLoad: Full-Size Img PowerPoint

It is clear from Fig. 2 that some points obtained by the proposed algorithm dominate to the suggested optimum point by [8] (such as Point $B$). Furthermore, the point $A$ has the best distance control of the cart and the worst angular control of the pendulums, while Point $C$ has the best angular control of the pendulums and the worst distance control of the cart. Design variables, objective functions, and maximum driving forces corresponding to the optimum design points are presented in Table Ⅱ. The time responses of cart and pendulums related to these points are shown in Figs. 3-5. Furthermore, Fig. 6 shows the driving forces of the optimum design points.

Table  Ⅱ.  THE VALUES OF OBJECTIVE FUNCTIONS AND THEIR ASSOCIATED DESIGN VARIABLES FOR THE OPTIMUM POINTS SHOWN IN FIG. 2

Optimum design points	A	B	C
w10	2.1641	2.1836	2.3155
w20	4.6814	4.5599	4.5901
w30	1.6095	1.6606	1.8544
w40	1.7101	1.7806	1.8062
w50	0.6906	0.4942	0.1584
w60	0.3902	0.2728	0.2391
B1	0.3754	0.4749	0.5054
B2	0.3731	0.2781	0.1263
B3	0.2986	0.3211	0.2213
B4	1.4978	1.3056	1.3865
B5	0.0000	0.0000	0.0000
B6	0.1055	0.1157	0.0851
OSF	14. 4369	14.5621	14.7365
The distance error of the cart (m)	0.4927	0.7183	1.9520
The summation of angle errorsof the pendulums (rad)	0.4228	0.3082	0.2428
Maximum driving force (N)	2.7922	2.7954	2.7302

 | Show Table

DownLoad: CSV

Figure  3.  Time responses of the longer pendulum for optimum design Points $A$, $B$, and $C$ shown in the Pareto front.

DownLoad: Full-Size Img PowerPoint

Figure  4.  Time responses of the shorter pendulum for optimum design Points $A$, $B$, and $C$ shown in the Pareto front.

DownLoad: Full-Size Img PowerPoint

Figure  5.  Time responses of the cart for optimum design Points $A$, $B$, and $C$ shown in the Pareto front.

DownLoad: Full-Size Img PowerPoint

Figure  6.  Driving forces for optimum design Points $A$, $B$, and $C$ shown in the Pareto front.

DownLoad: Full-Size Img PowerPoint

Ⅷ. JAVA PROGRAMMING FOR STABILITY SIMULATION OF DOUBLE INVERTED PENDULUM SYSTEM

Java is an object-oriented programming language, a runtime system, a set of development tools, and an application programming interface (API). The relationships among these elements are described in [1], [2].

Here, the Java applet is used to create the double inverted pendulum system and its SIRM fuzzy controller based on the proposed multi-objective particle swarm optimization. In fact, the coding of stability simulation via a computational tool as Java is to verify the obtained results in the previous section and education of internet-based control [1].

In the following, the main concepts of the Java programming are reviewed [43]$-$[45].

1) Classes, Methods, and Packages: Java programs consist of classes included methods. Java has many predefined named packages.

2) Java Development Environment: Java programs mainly have five phases: edit, compile, load, verify, and execute.

3) Inheritance: In Java, inheritance is a compile-time mechanism that extends a class to another class.

4) Applet: An applet program written in the Java programming language can be placed in an HTML page and has five methods: init, start, paint, stop, and destroy.

5) Multithreading: Multithreaded programs support more than one concurrent thread of execution and are able to execute the multiple sequences of instructions simultaneously.

For coding of stability simulation via Java, a package named JavaDoubleInvPend is defined. This package includes three classes named MainDIPClass, SIRMClass, and DIDClass as shown in Algorithms 2-4, respectively. Two classes, DIDClass and SIRMClass include methods that implement the equations in Sections Ⅲ and Ⅳ. MainDIPClass is one of Applet's subclasses and can inherit the Applet properties. Moreover, a method named DoubleInvPendSys( ) is defined in order to use the dynamic equations introduced in Section Ⅲ to achieve the position of the cart and pendulums (Algorithm 5). Hence, by using of these classes, we could achieve the position of the cart and pendulums. The simulation program can draw the double inverted pendulum system and its SIRM fuzzy controller based on the multi-objective particle swarm optimization. This action occurred every 0.01 s; so the Java animation would be created as shown in Fig. 7.

Figure  7.  Java simulation for the double inverted pendulum system.

DownLoad: Full-Size Img PowerPoint

Algorithm 2 MainDIPC lass used in Java code
MainDIPClass
Package javadoubleinvepend;
Public class MainDIPClass extends Applet implements Runnable{
Thread P1 = null;
boolean ThreadD;
public void init(){…}
public void run(){…}
public void start(){…}
public void stop(){…
public void paint(){…}
public void DoubleInvPend(){…}}

 | Show Table

DownLoad: CSV

Algorithm 3 SIRMClass used to implement the equations in Section Ⅲ
SIRMClass
Package javadoubleinvepend;
Public class SIRMClass {
MainDIPClass Obj = new MainDIPClass();
Public static double MainSIRMMeth(int index)
{
for (int i= 1; i < 7; i++)
nxi[i]=MainDIPClass. Nx[i];
for (int i = 1;i < 7;i++)
{
if (nxi[i] < -1)
{
NB[i]= 1;
ZO[i]= 0;
PB[i]=0;
}
else if (nxi[i] < = 0)
{
NB[i]=-nxi[i];
ZO[i] = nxi[i]+ 1;
PB[i]= 0;
}
else if (nxi[i] < = 1)
{
NB[i] = 0;
ZO[i]=-nxi[i]+1;
PB[i] = nxi[i];
}
else if (nxi[i] > 1)
{
NB[i] = 0;
ZO[i]= 0;
PB[i]= 1;
}
}
fi[index] = (NB[index]* f_NB[index] + ZO[index]* f_ZO[index]
+ PB[index]*f_PB[index])/(NB[index]+ZO[index]+PB[index]);
return fi[index];
}
}

 | Show Table

DownLoad: CSV

Algorithm 4 DIDC lass used to implement the equations in Section Ⅳ
DIDClass
Package javadoubleinvepend;
Public class DIDC lass
{
Public static double DID (double N_x1, double N_x3, int i)
{
double p = Math.abs(N_x1);
if (p < = 0.5)
{
DS1 = -2*p+ 1;
DM1=2*p;
DB1 = 0;
}
else if (p < = 1)
{
DS1 = 0;
DM1=-2*p+2;
DB1=2*p-1;
}
double q = Math.abs (N_x3);
if (q < = 0.5)
{
DS3= -2*q+1;
DM3 =2*q;
DB3= 0;
}
else if(q < = 1)
{
DS3= 0;
DM3=-2*q+2;
DB3=2*q-1;
}
delta_wD[1]= (w_DS1*DS1+ w_DM1*DM1
+w_DB1*DB1)/(DS1+DM1+DB1);
delta_wD[2] = delta_wD[1]; delta_wD[3]
=(w_DS3*DS3+w_DM3*DM3+w_DB3*DB3)
/(DS3+DM3+DB3);
delta_wD[4]=delta_wD[3];
delta_wD[5]= (w_DS1_DS3 * (DS1*DS3)+ w_DS1_DM3
*(DS1 * DM3)+ w_DM1__DS3 * (DM1 * DS3))
/(DS1 *DS3)+(DS1 *DM3)+(DS1 *DB3)+ (DM1 *DS3)
+(DMI * DM3)+ (DM1 * DB3) + (DB1 * DS3)
+(DB1 * DM3)+ (DB1 *DB3));
delta_wD[6] = delta_wD[5];
wD= w[i] + B[i] * delta_wD[i];
return wD;
}
}

 | Show Table

DownLoad: CSV

Algorithm 5 Method DoubleInvPend used in Java code
DoubleInvPend
public void DoubleInvPend()
{
$a11\, =\, m1 + m2 + M;$
$a12\, =\, m1 * l1$ * Math.cos($x$1);
$a13\, =\, m2 * l2$ * Math.cos($x$3);
$a21\, =\, a12;$
$a22\, =\, 4 * m1 * l1 * l1/3;$
$a31\, =\, a13;$
$a33\, =\, 4 * m2 * l2 * l2/3;$
$N_x[1] = x1/$(Math.PI/12);
$N_x[2] = x2/$(Math.PI/1.8);
$N_x[3] = x3/$(Math.PI/12);
$N_x[4] = x4/$(Math.PI/1.8);
$N_x[5] = x5/$(2.4);
$N_x[6] = x6$;
for (int $i = 1; i < 7;i++$)
wD$[i]$ = DIDClass.DID $(N_x[1], N_x[3s], i);$
for (int $i =1; i < 7; i++$)
fi$[i]$ = SIRMClass.MainSIRMMeth$(i)$;
for (int $j=1; j < 7; j++$)
{
$f+$ = wD$[j]$ * fi$[j]$
}
$u = f*Zf;$
$dx1=x2;$
$b1 = u+m1*l1*x2*x2*\textrm{ Math.sin}(x1)+m2*l2*x4*x4$
$*\textrm{ Math.sin}(x3);$
$b2 = m1*l1*\textrm{ gravity * Math.sin}(x1);$
$b3 = m2*l2*\textrm{ gravity * Math.sin}(x3);$
$dx2 =(b2-a21*((b1*a22*a33-a12*b2*a33 -a13*b3*a22)$
$/(a11*a22*a33-a12*a21*a33-a13*a31*a22)))/a22;$
$dx3 = x4;$
$dx4 = (b3-a31*((b1*a22*a33-a12*b2*a33-a13*b3*a22)$
$(a11*a22*a33-a12*a21*a33-a13*a31*a22)))/a33;$
$dx5 = x6;$
$dx6 = (b1*a22*a33-a12*b2*a33-a13*b3*a22)$
$/(a11*a22*a33-a12*a21*a33-a13*a31*a22);$
$x$1+ = deltaT * d$x$1;
$x$2+ = deltaT * d$x$2;
$x$3+ = deltaT * d$x$3;
$x$4+ = deltaT * d$x$4;
$x$5+ = deltaT * $x$6;
$x$6+ = deltaT * d$x$6;
posx = (int)($x$5 * coef);
pos$x$l1 = (int) (l1 * coef * Math.sin($x$1));
pos$x$l1 = (int) (l1 * coef * Math.cos($x$1));
pos$x$l2 = (int) (l2 * coef * Math.sin($x$3));
pos$y$l2 = (int) (l2 * coef * Math.cos($x$3));

 | Show Table

DownLoad: CSV

The variables of the DoubleInvPend( ) method are introduced in Table Ⅲ. Fig. 7 shows the results of Java program simulation. For this animation, the design variables of Point $C$ in Section Ⅴ are used. This figure and attached video file reveal when the pendulums are going to fall, the cart is moving to the same side until the pendulums go up. As it is seen from Fig. 7, the cart will reach the desired position at the end of simulation. These observations reinforce the obtained simulation results in Section Ⅴ.

Table  Ⅲ.  THE VARIABLES IN THE JAVA CODE

Variables	Description
u	Control effort
posx	The position of the cart
posxll	The x component of the position of the longer pendulum
posxl2	The x component of the position of the shorter pendulum
posyll	The y component of the position of the longer pendulum
posyl2	The y component of the position of the shorter pendulum
coef	The coefficient of pixels to appropriate and balance number for design

 | Show Table

DownLoad: CSV

Ⅸ. CONCLUSION

In this paper, an MOPSO algorithm was used, of which the leader selection method was based on density measures, the personal best positions were determined via Sigma method, the dynamic elimination technique was applied to prune the archive, and the turbulence operator was utilized to escape from the local minima. The proposed multi-objective algorithm was successfully used to obtain the Pareto frontiers of SIRMs dynamically connected fuzzy controllers for the double inverted pendulum system. The distance error of the cart and the summation errors of angles for the shorter and longer pendulums were considered as conflicting objective functions. The feasibility and efficiency of the proposed algorithm were shown in comparison with those obtained by two well-known multi-objective algorithms reported in the literature on this control problem. Furthermore, the modeling, control and stability simulation of the double inverted pendulum system were presented on the net using Java Applets with educational goals.