# Application of CMAC Neural Network to Solar Energy Heliostat Field Fault Diagnosis

Authors: Neng-Sheng Pai; Her-Terng Yau; Tzu-Hsiang Hung; Chin-Pao Hung
Journal: International Journal of Photoenergy
 (2013)

---

## Abstract

Solar energy heliostat fields comprise numerous sun tracking platforms. As a result, fault detection is a highly challenging problem. Accordingly, the present study proposes a cerebellar model arithmetic computer (CMAC) neutral network for automatically diagnosing faults within the heliostat field in accordance with the rotational speed, vibration, and temperature characteristics of the individual heliostat transmission systems. As compared with radial basis function (RBF) neural network and back propagation (BP) neural network in the heliostat field fault diagnosis, the experimental results show that the proposed neural network has a low training time, good robustness, and a reliable diagnostic performance. As a result, it provides an ideal solution for fault diagnosis in modern, large-scale heliostat fields.


---

## Body

## 1. Introduction

Heliostat fields play an essential role in concentrating the solar irradiation in tower solar power plant systems [1]. A modern heliostat field comprises hundreds or even thousands of individual heliostats, each of which is adjusted continuously so as to direct the incident light onto the receiver [2, 3]. However, the transmission systems of the heliostats are prone to various vibration, temperature, and rotational speed errors; and thus, the overall efficiency of the solar power plant is reduced [4–6]. Due to the sheer scale of modern heliostat fields, fault diagnosis is a highly challenging problem. Moreover, even if a faulty heliostat is successfully located, determining the precise nature of the fault is not easily achieved using traditional linear mapping techniques [7]. In a recent study, Cheng-Yu et al. [8] proposed a radial basis function (RBF) neural network for fault diagnosis in heliostat fields. The results showed that the proposed system had a better classification performance than diagnostic systems based on a back propagation (BP) neural network [9] or hybrid artificial neural network (ANN)/genetic algorithm (GA) scheme [10]. However, in both cases, the improved detection performance was obtained at the expense of a longer training time.Cerebellar model arithmetic computer (CMAC) neural networks are capable of classifying highly complex non linear dynamic systems with a high degree of accuracy and a short learning time. As a result, CMACs have found extensive use for fault diagnosis in such systems as automobile engines, internal combustion engines, and generators [11, 12]. Multilayer perceptron (MLP) or RBF neural networks achieve a mapping between the input and output data by means of a systematic weighting and aggregation of the excitation function outputs of multiple nodes configured in a small number of hidden layers. Such networks have a small scale, but incur a long computational time due to the hierarchical nature of the layer-by-layer mapping process. By contrast, in CMAC neural networks, the mapping process is performed by directly summing multiple weightings stored in the memory lattice. In other words, the mapping process involves only a simple addition operation. As a result, although a larger memory lattice is required to achieve the same mapping ability as that obtained using an MLP or RBF approach, the mapping time is significantly reduced. Thus, CMACs have emerged as a highly attractive solution for real-time fault diagnosis in complex, nondynamic systems [13].


## 2. Overview of CMAC Neural Networks

In CMAC neural networks, each memory address within the memory lattice stores a particular weighting value. During the training process, an input sample (vector) is selected and input to the CMAC, where it is quantized and encoded. The encoded vector is then processed by a hash function and used to excite a particular subset of the memory addresses within the lattice [14, 15]. The output vector corresponding to the input vector is then obtained by simply summing the weightings stored in the excited memory addresses. The output vector is compared with the ideal (target) output vector, and the weightings stored in the excited memory addresses are tuned by allocating the error between the two vectors equally among them. The process is then repeated using a new training sample. Given the input of a signal with an identical form to that of one of the previous samples, the same set of memory addresses is excited once again and the signal obtained by summing the tuned weighting values stored in the excited memory addresses is equal to the ideal output signal. Given the input of a signal vector containing noise, the similarity between the new input signal and the original signal is reduced. As a consequence, only some of the original memory addresses may be excited once again. Nonetheless, the output signal obtained by summing the weightings in the excited addresses retains many of the characteristics of the original output signal. As for the original training sample, the weightings of the memory addresses excited by the distorted signal are further tuned by distributing the error between the distorted output signal and the ideal output signal evenly among them. Having retuned the memorized weightings, the subsequent input of a signal vector with a similar degree of distortion yields an output signal with a form close to that of the target output signal.Figure1 illustrates the basic framework of a CMAC neural network [16]. Assume that the number of excited memory addresses (A*) is equal to 4. Assume further that an input vector x1 is applied to the input nodes of the CMAC. The weightings stored in the excited memory addresses are thus updated as w1, w2, w3, and w4, respectively. The output vector is obtained by summing the updated weightings of the four addresses and is then compared with the ideal output value. As described above, the error between the two vectors is allocated equally among the four weightings such that the subsequent reinput of the same signal yields the ideal output vector. Given the input of a new signal x2 similar to x1, the excited memory addresses may be w1, w2, w3, and w4 once again or may be w1, w2, w3,  and w5 (e.g.). Generally speaking, the greater the degree of similarity between the memory addresses excited by two different input signals, the greater the degree of similarityy between the two output signals. In the present example, three of the memory addresses excited by signal x2 are identical to those excited by signal x1 (i.e., w1, w2, and w3). Thus, assuming that the tuning process has been completed, the output signal will be close to the original output value.Figure 1
Schematic diagram of CMAC neural network.


## 3. Design of Proposed CMAC Fault Diagnosis System

As described in Section1, a heliostat field typically contains hundreds if not thousands of individual heliostats, each with its own controller. The heliostat field monitoring system communicates with all of the controllers in the heliostat field and performs fault diagnosis on the basis of the information received. Of all the various components within each heliostat, the turning gear is most commonly affected by faults and errors [10]. Thus, in developing the proposed CMAC neural network, the present study focuses specifically on the transmission system of each heliostat.


### 3.1. Fault Modes

The gears within the heliostat transmission system experience a range of common faults, including spalling, wear, scoring, breakage, pitting, and plastic deformation. As shown in Table1, these gear faults are annotated in this study as fault modes B ~ G, respectively. (Note that fault mode A denotes a normal gear operation.) For each fault mode, the output signal of the CMAC neural network has the form of a 7-element vector (T1, T2, T3, T4, T5, T6, T7). Note that for each vector, an element value of “0” indicates a normal output, while an element value of “0” indicates an abnormal output (i.e., a fault).Table 1
Gear fault modes.
Fault mode
Fault description
Output expression(T1–T7)
A
Normal gear
(1,0,0,0,0,0,0)
B
Gear spalling
(0,1,0,0,0,0,0)
C
Gear wear
(0,0,1,0,0,0,0)
D
Gear scoring
(0,0,0,1,0,0,0)
E
Gear breaking
(0,0,0,0,1,0,0)
F
Pitting of tooth flank
(0,0,0,0,0,1,0)
G
Plastic deformation of tooth flank
(0,0,0,0,0,0,1)


### 3.2. Selection of Sensing Points for Fault Diagnosis Purposes

Heliostats utilize a double-shaft transmission mechanism to accomplish rotational adjustments of the mirror in the azimuth and elevation planes, respectively. As shown in Figure2, the major components in each branch of the transmission system include an asynchronous motor, a reducer, a gear-cross shaft, and a gear upright shaft. Note that in Figure 2, labels 1, 2, 3, and 4 denote mechanical couplings; A1 and A2 are current vortex sensors, detecting the rotational speed of the corresponding motor shaft; B1, B2, B3, and B4 are acceleration sensors, detecting the gear vibration; and C1 and C2 are temperature sensors, detecting the gear case temperature. (Note that the gear case temperature is taken as an indication of the oil temperature within the case.) The analog signals generated by the velocity, vibration, and temperature sensors are amplified, converted to a digital form, and then transferred to the monitoring system for fault diagnostic purposes.Figure 2
Sensor positions in heliostat transmission system.In the transmission system shown in Figure2, the engagement vibration of the gears is transferred to the bearing via the shaft and is subsequently transferred to the gear case via the bearing pedestal. To measure the vibration accurately, the acceleration sensor should be attached to a position of high stiffness. Thus, in the present study, the acceleration sensors were attached to the bearing pedestals in a vertical direction. Furthermore, as shown in Figure 2, the current vortex sensors used to detect the rotational speed of the asynchronous motors were attached to the output side of the respective couplers. For each sensor in Figure 2, the measured signal was normalized as follows:
(1)yi=(xi-xmin)(xmax-xmin).
The normalized measurement data obtained from the rotational speed sensors (A1, A2), vibration sensors (B1, B2, B3, B4) and temperature sensors (C1, C2) were then used to construct an 8-element input vector for the CMAC neural network for fault diagnosis purposes.


## 3.1. Fault Modes

The gears within the heliostat transmission system experience a range of common faults, including spalling, wear, scoring, breakage, pitting, and plastic deformation. As shown in Table1, these gear faults are annotated in this study as fault modes B ~ G, respectively. (Note that fault mode A denotes a normal gear operation.) For each fault mode, the output signal of the CMAC neural network has the form of a 7-element vector (T1, T2, T3, T4, T5, T6, T7). Note that for each vector, an element value of “0” indicates a normal output, while an element value of “0” indicates an abnormal output (i.e., a fault).Table 1
Gear fault modes.
Fault mode
Fault description
Output expression(T1–T7)
A
Normal gear
(1,0,0,0,0,0,0)
B
Gear spalling
(0,1,0,0,0,0,0)
C
Gear wear
(0,0,1,0,0,0,0)
D
Gear scoring
(0,0,0,1,0,0,0)
E
Gear breaking
(0,0,0,0,1,0,0)
F
Pitting of tooth flank
(0,0,0,0,0,1,0)
G
Plastic deformation of tooth flank
(0,0,0,0,0,0,1)


## 3.2. Selection of Sensing Points for Fault Diagnosis Purposes

Heliostats utilize a double-shaft transmission mechanism to accomplish rotational adjustments of the mirror in the azimuth and elevation planes, respectively. As shown in Figure2, the major components in each branch of the transmission system include an asynchronous motor, a reducer, a gear-cross shaft, and a gear upright shaft. Note that in Figure 2, labels 1, 2, 3, and 4 denote mechanical couplings; A1 and A2 are current vortex sensors, detecting the rotational speed of the corresponding motor shaft; B1, B2, B3, and B4 are acceleration sensors, detecting the gear vibration; and C1 and C2 are temperature sensors, detecting the gear case temperature. (Note that the gear case temperature is taken as an indication of the oil temperature within the case.) The analog signals generated by the velocity, vibration, and temperature sensors are amplified, converted to a digital form, and then transferred to the monitoring system for fault diagnostic purposes.Figure 2
Sensor positions in heliostat transmission system.In the transmission system shown in Figure2, the engagement vibration of the gears is transferred to the bearing via the shaft and is subsequently transferred to the gear case via the bearing pedestal. To measure the vibration accurately, the acceleration sensor should be attached to a position of high stiffness. Thus, in the present study, the acceleration sensors were attached to the bearing pedestals in a vertical direction. Furthermore, as shown in Figure 2, the current vortex sensors used to detect the rotational speed of the asynchronous motors were attached to the output side of the respective couplers. For each sensor in Figure 2, the measured signal was normalized as follows:
(1)yi=(xi-xmin)(xmax-xmin).
The normalized measurement data obtained from the rotational speed sensors (A1, A2), vibration sensors (B1, B2, B3, B4) and temperature sensors (C1, C2) were then used to construct an 8-element input vector for the CMAC neural network for fault diagnosis purposes.


## 4. CMAC Neural Network Training

Table2 shows the sample data used to train the CMAC neural network. Table 3 shows the corresponding fault modes of the 20 training samples. In implementing the CMAC neural network model shown in Figure 1, the quantization step size is specified as 64 bits and the encoded fault following quantization has a length of 48 bits. Since there are seven output classes (see Table 1), a total of six memory layers are required. Furthermore, since the input signal has the form of an 8-element vector (see Section 3), each memory layer is partitioned into eight groups, with each group having six bits.Table 2
Training samples.
No.
A1
A2
B1
B2
B3
B4
C1
C2
1
0.58
0.64
0.19
0.25
0.23
0.14
0.36
0.41
2
0.65
0.89
0.16
0.25
0.48
0.35
0.38
0.45
3
0.54
0.59
0.62
0.68
0.36
0.41
0.58
0.37
4
0.59
0.64
0.39
0.42
0.61
0.54
0.35
0.60
5
0.60
0.40
0.62
0.58
0.79
0.87
0.32
0.60
6
0.55
0.64
0.12
0.20
0.35
0.40
0.45
0.39
7
0.59
0.15
0.57
0.53
0.86
0.74
0.59
0.90
8
0.53
0.70
0.13
0.24
0.32
0.41
0.36
0.61
9
0.90
0.81
0.33
0.43
0.49
0.31
0.46
0.40
10
0.55
0.59
0.61
0.68
0.57
0.51
0.69
0.62
11
0.51
0.56
0.31
0.40
0.46
0.41
0.50
0.67
12
0.10
0.21
0.85
0.79
0.86
0.73
0.76
0.88
13
0.50
0.61
0.40
0.35
0.45
0.41
0.47
0.34
14
0.33
0.45
0.80
0.76
0.91
0.81
0.59
0.63
15
0.53
0.58
0.32
0.41
0.09
0.15
0.30
0.41
16
0.50
0.78
0.12
0.24
0.35
0.31
0.42
0.46
17
0.32
0.41
0.75
0.81
0.56
0.67
0.62
0.40
18
0.53
0.61
0.22
0.13
0.23
0.24
0.39
0.43
19
0.55
0.60
0.36
0.39
0.19
0.08
0.57
0.35
20
0.15
0.36
0.81
0.92
0.54
0.61
0.75
0.51Table 3
Fault modes of training samples.
No.
Fault mode
1
(
1,0
,
0,0
,
0,0
,
0
)
2
(
0,1
,
0,0
,
0,0
,
0
)
3
(
0,0
,
0,1
,
0,0
,
0
)
4
(
0,0
,
0,1
,
0,0
,
0
)
5
(
0,0
,
0,0
,
0,0
,
1
)
6
(
0,0
,
1,0
,
0,0
,
0
)
7
(
0,0
,
0,0
,
1,0
,
0
)
8
(
0,0
,
0,0
,
0,1
,
0
)
9
(
0,1
,
0,0
,
0,0
,
0
)
10
(
0,0
,
0,1
,
0,0
,
0
)
11
(
0,0
,
0,0
,
0,1
,
0
)
12
(
0,0
,
0,0
,
1,0
,
0
)
13
(
0,0
,
1,0
,
0,0
,
0
)
14
(
0,0
,
0,0
,
0,0
,
1
)
15
(
0,0
,
1,0
,
0,0
,
0
)
16
(
0,1
,
0,0
,
0,0
,
0
)
17
(
0,0
,
0,0
,
0,0
,
1
)
18
(
1,0
,
0,0
,
0,0
,
0
)
19
(
0,0
,
0,0
,
0,1
,
0
)
20
(
0,0
,
0,0
,
1,0
,
0
)An output value can be obtained after quantization, concatenation, excited address coding, and totaling of the excited address weightings in the CMAC neural network. In performing the training process, given a fault sample of theith (i=1,2,…) type, only the ith layer of memory is excited and trained. In the subsequent diagnosis phase, if the same addresses in each group of memory bits are excited, the fault type is identified in accordance with the output value of each layer.


### 4.1. Quantization

The input data for the CMAC neural network developed in the present study all fall within a given range, that is,[Xmin,Xmax]. As shown in Figure 3, each input data instance is quantized using an equidistant quantization scheme based on the maximum and minimum values of the corresponding range.Figure 3
Schematic representation of equidistant quantization scheme.In performing the quantization process, the quantized value of any input value less thanXmin is set to 0, while the quantized value of any input value greater than Xmax is set to Xmax. The quantized values of the remaining input values are determined in accordance with
(2)Qxi(xi)=ceil(xi-min)[(max-min)/Q],
where ceil (x) is a Matlab function which causes the quantization process to yield the integer value closest to x towards infinity.


### 4.2. Excited Address Coding and CMAC Output Calculation

As described above, the recoded fault code following quantization comprises 48 bits, partitioned into eight 6-bit groups. Assume that the quantized fault code has the form 101000000000000000000000000100001010000011101101b. For this particular example, the eight excited addresses coded sequentially from the LSB to the MSB are as follows:a1=101101b=45, a2=000011=3, a3=001010=10, a4=000100=4, a5=000000=0, a6=000000=0, a7=000000=0, and a8=101000=40. Assuming that all of the excited addresses store an initial weighting of zero, the total memory weighting excited by the first input sample is equal to 0,  W02, W05,  W08, W017, W025. The output of the CMAC neural network can thus be expressed as
(3)y=∑i=1A*Wiai,
where A* is the total number of excited memory addresses.


### 4.3. Update Weightings

In the CMAC neural network developed in the present study, the weightings stored in the memory lattice are updated using the method of the steepest descent [15, 16], that is,
(4)W(new)ai⟵W(old)ai+βYd-YA*,i=1,2,…A*,
where W(new)ai is the adjusted weighting, W(old)ai is the previous weighting, ai is the excited memory address, β is the learning gain (0<β≤1), Yd  is the target value (set as 1 in the present study), and Y is the actual output value. It is noted that β can be sent directly to 1 if each fault type has only one group. However, for more than one sample data, β usually has a value slightly less than 1.The memory consumption of each layer in the CMAC is related to the number of bits per group (m). Moreover, the total memory consumption of the CMAC is determined by the number of groups, the number of the length of the encoded fault following quantization (n), and the number of fault types (f). In the CMAC developed in the present study, A*=8, m=6, n=48, and f=6. The total number of memory addresses in the CMAC is given by
(5)Mtotal=A*·f·2m=ceil(nm)·f·2m.
Thus, the total number of memory addresses in the present CMAC is equal to 8 × 6 × 32 = 1536.In (5), n/m is not guaranteed to be exactly divisible. Thus, ceil represents an unconditional carry function. In other words, the insufficient bit of MSB will fill 0 in the proper order automatically during grouping. Considering the consumption of memory, the ceil function is neglected and (5) is differentiated with respect to m to determine the number of bits per group which minimizes the total memory consumption, That is,
(6)∂Mtotal∂m=(-nm2)·f·2m+nm·Ln2·2m=0.


### 4.4. Convergence of CMAC

The convergence properties of CMAC neural networks have been extensively examined in the literature [17]. In the CMAC developed in the present study, the memory consumption is reduced by means of an appropriate encoding mode which ensures that no collisions occur during the weighting process. (Note that a collision is defined here as the case where two different input signals excite the same set of memory addresses.) As a result, the convergence of the learning process is ensured.Let the total weighting of the excited addresses on theith (i=1,2,3,…) memory layer be equal to 1 and represent the ith fault. Furthermore, let the number of data samples corresponding to the ith fault type be equal to d. The following evaluation index is then introduced:
(7)E=∑i-1d(Yi-1)2,
where the value of E represents the learning effect. Define ε as a number greater than 0. The training process terminates once the condition E<ε is achieved.


## 4.1. Quantization

The input data for the CMAC neural network developed in the present study all fall within a given range, that is,[Xmin,Xmax]. As shown in Figure 3, each input data instance is quantized using an equidistant quantization scheme based on the maximum and minimum values of the corresponding range.Figure 3
Schematic representation of equidistant quantization scheme.In performing the quantization process, the quantized value of any input value less thanXmin is set to 0, while the quantized value of any input value greater than Xmax is set to Xmax. The quantized values of the remaining input values are determined in accordance with
(2)Qxi(xi)=ceil(xi-min)[(max-min)/Q],
where ceil (x) is a Matlab function which causes the quantization process to yield the integer value closest to x towards infinity.


## 4.2. Excited Address Coding and CMAC Output Calculation

As described above, the recoded fault code following quantization comprises 48 bits, partitioned into eight 6-bit groups. Assume that the quantized fault code has the form 101000000000000000000000000100001010000011101101b. For this particular example, the eight excited addresses coded sequentially from the LSB to the MSB are as follows:a1=101101b=45, a2=000011=3, a3=001010=10, a4=000100=4, a5=000000=0, a6=000000=0, a7=000000=0, and a8=101000=40. Assuming that all of the excited addresses store an initial weighting of zero, the total memory weighting excited by the first input sample is equal to 0,  W02, W05,  W08, W017, W025. The output of the CMAC neural network can thus be expressed as
(3)y=∑i=1A*Wiai,
where A* is the total number of excited memory addresses.


## 4.3. Update Weightings

In the CMAC neural network developed in the present study, the weightings stored in the memory lattice are updated using the method of the steepest descent [15, 16], that is,
(4)W(new)ai⟵W(old)ai+βYd-YA*,i=1,2,…A*,
where W(new)ai is the adjusted weighting, W(old)ai is the previous weighting, ai is the excited memory address, β is the learning gain (0<β≤1), Yd  is the target value (set as 1 in the present study), and Y is the actual output value. It is noted that β can be sent directly to 1 if each fault type has only one group. However, for more than one sample data, β usually has a value slightly less than 1.The memory consumption of each layer in the CMAC is related to the number of bits per group (m). Moreover, the total memory consumption of the CMAC is determined by the number of groups, the number of the length of the encoded fault following quantization (n), and the number of fault types (f). In the CMAC developed in the present study, A*=8, m=6, n=48, and f=6. The total number of memory addresses in the CMAC is given by
(5)Mtotal=A*·f·2m=ceil(nm)·f·2m.
Thus, the total number of memory addresses in the present CMAC is equal to 8 × 6 × 32 = 1536.In (5), n/m is not guaranteed to be exactly divisible. Thus, ceil represents an unconditional carry function. In other words, the insufficient bit of MSB will fill 0 in the proper order automatically during grouping. Considering the consumption of memory, the ceil function is neglected and (5) is differentiated with respect to m to determine the number of bits per group which minimizes the total memory consumption, That is,
(6)∂Mtotal∂m=(-nm2)·f·2m+nm·Ln2·2m=0.


## 4.4. Convergence of CMAC

The convergence properties of CMAC neural networks have been extensively examined in the literature [17]. In the CMAC developed in the present study, the memory consumption is reduced by means of an appropriate encoding mode which ensures that no collisions occur during the weighting process. (Note that a collision is defined here as the case where two different input signals excite the same set of memory addresses.) As a result, the convergence of the learning process is ensured.Let the total weighting of the excited addresses on theith (i=1,2,3,…) memory layer be equal to 1 and represent the ith fault. Furthermore, let the number of data samples corresponding to the ith fault type be equal to d. The following evaluation index is then introduced:
(7)E=∑i-1d(Yi-1)2,
where the value of E represents the learning effect. Define ε as a number greater than 0. The training process terminates once the condition E<ε is achieved.


## 5. Offline and Online Learning Modes

The learning modes and fault diagnosis rules proposed in this study are summarized as follows.


### 5.1. Offline Learning Mode

Step 1.
Determine CMAC parameter settings (i.e., quantization step size: 64, memory layer: 48 bits, 8 groups, 6 bits per group).Step 2.
Import training samples into CMAC, quantize sample data, and sum excited memory addresses to obtain output signal.Step 3.
Compare output value (y) with ideal value (Yd) and use (4) to update memory weightings if required.Step 4.
Check if all of the input training samples have been processed. If not, return to Step2; else, proceed to Step 5.Step 5.
Evaluate the learning performance. IfE<ε, save the current set of memory weightings; else, return to Step 2.
In practice, the time required to complete the offline learning process depends on the number of training data samples. In the present study, the CMAC is trained using just 20 samples (see Table1). Hence, the training time is very short (less than one second). Figure 4 presents a flowchart showing the overall framework of the offline learning process.Figure 4
Flowchart of offline learning process.


### 5.2. Online Learning Mode

Having completed the offline learning process, the fault diagnosis procedure is performed as follows.Step 6.
Import memory weightings obtained in offline learning mode.Step 7.
Import diagnostic data.Step 8.
Perform quantization, binary combination coding, concatenation, and excited address coding. Sum the weightings of the excited addresses in order to obtain the output values of the various nodes.Step 9.
Compare the diagnosis result with the target result. If the diagnosis is correct, proceed to Step10; else skip to Step 11.Step 10.
Check whether or not all of the input diagnostic data have been classified. If not all of the diagnostic data have been processed, return to Step7; else skip to Step 12.Step 11.
Use (4) to update the memory weightings and then return to Step 10.Step 12.
Save the latest memory weighting values. Terminate the diagnosis procedure.
Figure5 presents a flowchart showing the overall framework of the online learning process.Figure 5
Flowchart of online learning process.


## 5.1. Offline Learning Mode

Step 1.
Determine CMAC parameter settings (i.e., quantization step size: 64, memory layer: 48 bits, 8 groups, 6 bits per group).Step 2.
Import training samples into CMAC, quantize sample data, and sum excited memory addresses to obtain output signal.Step 3.
Compare output value (y) with ideal value (Yd) and use (4) to update memory weightings if required.Step 4.
Check if all of the input training samples have been processed. If not, return to Step2; else, proceed to Step 5.Step 5.
Evaluate the learning performance. IfE<ε, save the current set of memory weightings; else, return to Step 2.
In practice, the time required to complete the offline learning process depends on the number of training data samples. In the present study, the CMAC is trained using just 20 samples (see Table1). Hence, the training time is very short (less than one second). Figure 4 presents a flowchart showing the overall framework of the offline learning process.Figure 4
Flowchart of offline learning process.


## 5.2. Online Learning Mode

Having completed the offline learning process, the fault diagnosis procedure is performed as follows.Step 6.
Import memory weightings obtained in offline learning mode.Step 7.
Import diagnostic data.Step 8.
Perform quantization, binary combination coding, concatenation, and excited address coding. Sum the weightings of the excited addresses in order to obtain the output values of the various nodes.Step 9.
Compare the diagnosis result with the target result. If the diagnosis is correct, proceed to Step10; else skip to Step 11.Step 10.
Check whether or not all of the input diagnostic data have been classified. If not all of the diagnostic data have been processed, return to Step7; else skip to Step 12.Step 11.
Use (4) to update the memory weightings and then return to Step 10.Step 12.
Save the latest memory weighting values. Terminate the diagnosis procedure.
Figure5 presents a flowchart showing the overall framework of the online learning process.Figure 5
Flowchart of online learning process.


## 6. Experimental Results and Analysis

For convenience, Tables4 and 5 list the 20 training samples given in Table 2 in order of their fault type.Table 4
Training samples ordered by fault type.
No.
A1
A2
B1
B2
B3
B4
C1
C2
1
0.58
0.64
0.19
0.25
0.23
0.14
0.36
0.41
2
0.53
0.61
0.22
0.13
0.23
0.24
0.39
0.43
3
0.65
0.89
0.16
0.25
0.48
0.35
0.38
0.45
4
0.90
0.81
0.33
0.43
0.49
0.31
0.46
0.40
5
0.50
0.78
0.12
0.24
0.35
0.31
0.42
0.46
6
0.55
0.64
0.12
0.20
0.35
0.40
0.45
0.39
7
0.50
0.61
0.40
0.35
0.45
0.41
0.47
0.34
8
0.53
0.58
0.32
0.41
0.09
0.15
0.30
0.41
9
0.54
0.59
0.62
0.68
0.36
0.41
0.58
0.37
10
0.59
0.64
0.39
0.42
0.61
0.54
0.35
0.60
11
0.55
0.59
0.61
0.68
0.57
0.51
0.69
0.62
12
0.59
0.15
0.57
0.53
0.86
0.74
0.59
0.90
13
0.10
0.21
0.85
0.79
0.86
0.73
0.76
0.88
14
0.15
0.36
0.81
0.92
0.54
0.61
0.75
0.51
15
0.53
0.70
0.13
0.24
0.32
0.41
0.36
0.61
16
0.51
0.56
0.31
0.40
0.46
0.41
0.50
0.67
17
0.55
0.60
0.36
0.39
0.19
0.08
0.57
0.35
18
0.60
0.40
0.62
0.58
0.79
0.87
0.32
0.60
19
0.33
0.45
0.80
0.76
0.91
0.81
0.59
0.63
20
0.32
0.41
0.75
0.81
0.56
0.67
0.62
0.40Table 5
Fault modes of ordered training samples.
No.
Fault mode
1
(
1,0
,
0,0
,
0,0
,
0
)
2
(
1,0
,
0,0
,
0,0
,
0
)
3
(
0,1
,
0,0
,
0,0
,
0
)
4
(
0,1
,
0,0
,
0,0
,
0
)
5
(
0,1
,
0,0
,
0,0
,
0
)
6
(
0,0
,
1,0
,
0,0
,
0
)
7
(
0,0
,
1,0
,
0,0
,
0
)
8
(
0,0
,
1,0
,
0,0
,
0
)
9
(
0,0
,
0,1
,
0,0
,
0
)
10
(
0,0
,
0,1
,
0,0
,
0
)
11
(
0,0
,
0,1
,
0,0
,
0
)
12
(
0,0
,
0,0
,
1,0
,
0
)
13
(
0,0
,
0,0
,
1,0
,
0
)
14
(
0,0
,
0,0
,
1,0
,
0
)
15
(
0,0
,
0,0
,
0,1
,
0
)
16
(
0,0
,
0,0
,
0,1
,
0
)
17
(
0,0
,
0,0
,
0,1
,
0
)
18
(
0,0
,
0,0
,
0,0
,
1
)
19
(
0,0
,
0,0
,
0,0
,
1
)
20
(
0,0
,
0,0
,
0,0
,
1
)The learning process was repeated 10 times using the sample data given in Table4. The corresponding diagnosis results are presented in Table 6. It appears from a comparison of Tables 5 and 6 that the CMAC achieves a 100% success rate in diagnosing the input data samples.Table 6
Diagnosis results for training samples given in Table4.
No.
T
1
T
2
T
3
T
4
T
5
T
6
T
7
1
1.000
0
0
0
0
0
0
2
1.000
0
0
0
0
0
0
3
0
1.000
0
0
0
0
0
4
0
1.000
0
0
0
0
0
5
0
1.000
0
0
0
0
0
6
0
0
1.000
0
0
0
0
7
0
0
1.000
0
0
0
0
8
0
0
1.000
0
0
0
0
9
0
0
0
1.000
0
0
0
10
0
0
0
1.000
0
0
0
11
0
0
0
1.000
0
0
0
12
0
0
0
0
1.000
0
0
13
0
0
0
0
1.000
0
0
14
0
0
0
0
1.000
0
0
15
0
0
0
0
0
1.000
0
16
0
0
0
0
0
1.000
0
17
0
0
0
0
0
1.000
0
18
0
0
0
0
0
0
1.000
19
0
0
0
0
0
0
1.000
20
0
0
0
0
0
0
1.000To evaluate the robustness of the proposed CMAC diagnosis system, the first 10 training samples in Table2 were distorted using a random 10~40% interference signal. The resulting test samples are shown in Table 7, in which the distorted values are shown in italics.Table 7
Distorted test sample data.
No.
A1
A2
B1
B2
B3
B4
C1
C2
1
0.69
0.64
0.19
0.25
0.23
0.14
0.50
0.41
2
0.65
0.89
0.16
0.25
0.53
0.35
0.38
0.45
3
0.54
0.59
0.80
0.68
0.36
0.41
0.58
0.48
4
0.59
0.64
0.39
0.42
0.61
0.54
0.35
0.72
5
0.84
0.40
0.62
0.81
0.79
0.87
0.32
0.60
6
0.55
0.77
0.12
0.20
0.35
0.52
0.45
0.39
7
0.59
0.15
0.57
0.63
0.86
0.74
0.59
0.90
8
0.53
0.70
0.13
0.24
0.35
0.41
0.47
0.61
9
0.90
0.89
0.33
0.43
0.49
0.31
0.46
0.52
10
0.55
0.59
0.61
0.68
0.63
0.51
0.69
0.62The training procedure was repeated 10 times using the distorted test data given in Table7. The corresponding diagnosis results are shown in Table 8. The bold numbers show the diagnosis results with the distorted test data.Table 8
Diagnosis results for distorted training samples given in Table7.
No.
T
1
T
2
T
3
T
4
T
5
T
6
T
7
1
0.778
0.113
0.236
0.125
0
0.111
0
2
0.111
0.790
0
0
0
0
0
3
0
0
0.458
0.818
0
0.347
0.111
4
0.222
0
0.236
0.875
0.1
0
0
5
0
0
0
0.216
0
0
0.861
6
0.111
0.226
0.667
0.182
0
0.125
0
7
0.111
0
0
0.125
0.90
0
0.111
8
0.111
0.226
0.569
0.091
0
0.778
0
9
0
0.71
0
0
0
0
0
10
0
0
0.236
0.909
0
0.125
0The results presented in Table8 confirm that the CMAC correctly diagnoses the input fault even when the input data contains 10~40% noise. In other words, the robustness of the proposed fault diagnosis system toward noise in the input data is confirmed.


## 7. Conclusions

Heliostat fields contain hundreds if not thousands of individual heliostats, each with their own independent controller. As a result, fault diagnosis via a remote monitoring system is highly challenging. Existing RBF and BP neural network approaches for fault diagnosis in heliostat fields achieve an accurate classification performance, but require a long training time. Accordingly, this study has presented a new approach for fault diagnosis in large-scale heliostat fields by means of a CMAC neural network. The experimental results have shown that the proposed system has a short learning time, a high classification performance and a good robustness toward noise in the input signal.



---

*Source: 938162-2013-01-01.xml*