Fuzzy control in detail

Fuzzy controllers are very simple conceptually. They consist of an input stage, a processing stage, and an output stage. The input stage maps sensor or other inputs, such as switches, thumbwheels, and so on, to the appropriate membership functions and truth values. The processing stage invokes each appropriate rule and generates a result for each, then combines the results of the rules. Finally, the output stage converts the combined result back into a specific control output value.

The most common shape of membership functions is triangular, although trapezoidal and bell curves are also used, but the shape is generally less important than the number of curves and their placement. From three to seven curves are generally appropriate to cover the required range of an input value, or the "universe of discourse" in fuzzy jargon.

As discussed earlier, the processing stage is based on a collection of logic rules in the form of IF-THEN statements, where the IF part is called the "antecedent" and the THEN part is called the "consequent". Typical fuzzy control systems have dozens of rules.

Consider a rule for a thermostat:

  IF (temperature is "cold") THEN turn (heater is "high")

This rule uses the truth value of the "temperature" input, which is some truth value of "cold", to generate a result in the fuzzy set for the "heater" output, which is some value of "high". This result is used with the results of other rules to finally generate the crisp composite output. Obviously, the greater the truth value of "cold", the higher the truth value of "high", though this does not necessarily mean that the output itself will be set to "high" since this is only one rule among many. In some cases, the membership functions can be modified by "hedges" that are equivalent to adverbs. Common hedges include "about", "near", "close to", "approximately", "very", "slightly", "too", "extremely", and "somewhat". These operations may have precise definitions, though the definitions can vary considerably between different implementations. "Very", for one example, squares membership functions; since the membership values are always less than 1, this narrows the membership function. "Extremely" cubes the values to give greater narrowing, while "somewhat" broadens the function by taking the square root.

In practice, the fuzzy rule sets usually have several antecedents that are combined using fuzzy operators, such as AND, OR, and NOT, though again the definitions tend to vary: AND, in one popular definition, simply uses the minimum weight of all the antecedents, while OR uses the maximum value. There is also a NOT operator that subtracts a membership function from 1 to give the "complementary" function.

There are several ways to define the result of a rule, but one of the most common and simplest is the "max-min" inference method, in which the output membership function is given the truth value generated by the premise.

Rules can be solved in parallel in hardware, or sequentially in software. The results of all the rules that have fired are "defuzzified" to a crisp value by one of several methods. There are dozens, in theory, each with various advantages or drawbacks.

The "centroid" method is very popular, in which the "center of mass" of the result provides the crisp value. Another approach is the "height" method, which takes the value of the biggest contributor. The centroid method favors the rule with the output of greatest area, while the height method obviously favors the rule with the greatest output value.

The diagram below demonstrates max-min inferencing and centroid defuzzification for a system with input variables "x", "y", and "z" and an output variable "n". Note that "mu" is standard fuzzy-logic nomenclature for "truth value":

Notice how each rule provides a result as a truth value of a particular membership function for the output variable. In centroid defuzzification the values are OR'd, that is, the maximum value is used and values are not added, and the results are then combined using a centroid calculation.

Fuzzy control system design is based on empirical methods, basically a methodical approach to trial-and-error. The general process is as follows:

• Document the system's operational specifications and inputs and outputs.
• Document the fuzzy sets for the inputs.
• Document the rule set.
• Determine the defuzzification method.
• Run through test suite to validate system, adjust details as required.
• Complete document and release to production.

As a general example, consider the design of a fuzzy controller for a steam turbine. The block diagram of this control system appears as follows:

The input and output variables map into the following fuzzy set:

—where:

  N3:   Large negative.
  N2:   Medium negative.
  N1:   Small negative.
  Z:    Zero.
  P1:   Small positive.
  P2:   Medium positive.
  P3:   Large positive.

The rule set includes such rules as:

rule 1:  IF temperature IS cool AND pressure IS weak,   
         THEN throttle is P3.

rule 2:  IF temperature IS cool AND pressure IS low,    
         THEN throttle is P2.

rule 3:  IF temperature IS cool AND pressure IS ok,     
         THEN throttle is Z.

rule 4:  IF temperature IS cool AND pressure IS strong, 
         THEN throttle is N2.

In practice, the controller accepts the inputs and maps them into their membership functions and truth values. These mappings are then fed into the rules. If the rule specifies an AND relationship between the mappings of the two input variables, as the examples above do, the minimum of the two is used as the combined truth value; if an OR is specified, the maximum is used. The appropriate output state is selected and assigned a membership value at the truth level of the premise. The truth values are then defuzzified. For example, assume the temperature is in the "cool" state, and the pressure is in the "low" and "ok" states. The pressure values ensure that only rules 2 and 3 fire:

The two outputs are then defuzzified through centroid defuzzification:

   __________________________________________________________________

                                       |          Z      P2
                                    1 -+          *       *
                                       |         * *     * *
                                       |        *   *   *   *
                                       |       *     * *     *
                                       |      *       222222222
                                       |     *       22222222222
                                       |    333333332222222222222
                                       +---33333333222222222222222-->
                                                        ^ 
                                                      +150 
   __________________________________________________________________

The output value will adjust the throttle and then the control cycle will begin again to generate the next value.

Building a fuzzy controller

Consider implementing with a microcontroller chip a simple feedback controller:

A fuzzy set is defined for the input error variable "e", and the derived change in error, "delta", as well as the "output", as follows:

  LP:  large positive
  SP:  small positive
  ZE:  zero
  SN:  small negative
  LN:  large negative

If the error ranges from -1 to +1, with the analog-to-digital converter used having a resolution of 0.25, then the input variable's fuzzy set (which, in this case, also applies to the output variable) can be described very simply as a table, with the error / delta / output values in the top row and the truth values for each membership function arranged in rows beneath:

  _______________________________________________________________________

              -1    -0.75  -0.5   -0.25    0     0.25   0.5    0.75    1
  _______________________________________________________________________

   mu(LP)      0      0      0      0      0      0     0.3    0.7     1
   mu(SP)      0      0      0      0     0.3    0.7     1     0.7    0.3
   mu(ZE)      0      0     0.3    0.7     1     0.7    0.3     0      0
   mu(SN)     0.3    0.7     1     0.7    0.3     0      0      0      0
   mu(LN)      1     0.7    0.3     0      0      0      0      0      0
  _______________________________________________________________________            —or, in graphical form (where each "X" has a value of 0.1):

         LN           SN           ZE           SP           LP
      +------------------------------------------------------------------+
      |                                                                  |
-1.0  |  XXXXXXXXXX   XXX          :            :            :           |
-0.75 |  XXXXXXX      XXXXXXX      :            :            :           |
-0.5  |  XXX          XXXXXXXXXX   XXX          :            :           |
-0.25 |  :            XXXXXXX      XXXXXXX      :            :           |
 0.0  |  :            XXX          XXXXXXXXXX   XXX          :           |
 0.25 |  :            :            XXXXXXX      XXXXXXX      :           |
 0.5  |  :            :            XXX          XXXXXXXXXX   XXX         |
 0.75 |  :            :            :            XXXXXXX      XXXXXXX     |
 1.0  |  :            :            :            XXX          XXXXXXXXXX  |
      |                                                                  |
      +------------------------------------------------------------------+

Suppose this fuzzy system has the following rule base:

  rule 1:  IF e = ZE AND delta = ZE THEN output = ZE
  rule 2:  IF e = ZE AND delta = SP THEN output = SN
  rule 3:  IF e = SN AND delta = SN THEN output = LP
  rule 4:  IF e = LP OR  delta = LP THEN output = LN

These rules are typical for control applications in that the antecedents consist of the logical combination of the error and error-delta signals, while the consequent is a control command output. The rule outputs can be defuzzified using a discrete centroid computation:

  SUM( I = 1 TO 4 OF ( mu(I) * output(I) ) ) / SUM( I = 1 TO 4 OF mu(I) )

Now, suppose that at a given time:

  e     = 0.25
  delta = 0.5

Then this gives:

  ________________________

              e     delta
  ________________________

  mu(LP)      0      0.3
  mu(SP)     0.7      1
  mu(ZE)     0.7     0.3
  mu(SN)      0       0
  mu(LN)      0       0
  ________________________

Plugging this into rule 1 gives:

  rule 1:  IF e = ZE AND delta = ZE THEN output = ZE
 
     mu(1)     = MIN( 0.7, 0.3 ) = 0.3
     output(1) = 0

-- where:

• mu(1): Truth value of the result membership function for rule 1. In terms of a centroid calculation, this is the "mass" of this result for this discrete case.
• output(1): Value (for rule 1) where the result membership function (ZE) is maximum over the output variable fuzzy set range. That is, in terms of a centroid calculation, the location of the "center of mass" for this individual result. This value is independent of the value of "mu". It simply identifies the location of ZE along the output range.

The other rules give:

  rule 2:  IF e = ZE AND delta = SP THEN output = SN

     mu(2)     = MIN( 0.7, 1 ) = 0.7   
     output(2) = -0.5

  rule 3: IF e = SN AND delta = SN THEN output = LP

     mu(3)     = MIN( 0.0, 0.0 ) = 0
     output(3) = 1

  rule 4: IF e = LP OR  delta = LP THEN output = LN

     mu(4)     = MAX( 0.0, 0.3 ) = 0.3
     output(4) = -1

The centroid computation yields:

  ${\displaystyle {\frac {mu(1)\cdot output(1)+mu(2)\cdot output(2)+mu(3)\cdot output(3)+mu(4)\cdot output(4)}{mu(1)+mu(2)+mu(3)+mu(4)}}}$
  ${\displaystyle ={\frac {(0.3\cdot 0)+(0.7\cdot -0.5)+(0\cdot 1)+(0.3\cdot -1)}{0.3+0.7+0+0.3}}}$
  ${\displaystyle =-0.5}$—for the final control output. Simple. Of course the hard part is figuring out what rules actually work correctly in practice.

If you have problems figuring out the centroid equation, remember that a centroid is defined by summing all the moments (location times mass) around the center of gravity and equating the sum to zero. So if ${\displaystyle X_{0}}$ is the center of gravity, ${\displaystyle X_{i}}$ is the location of each mass, and ${\displaystyle M_{i}}$ is each mass, this gives:

  ${\displaystyle 0=(X_{1}-X_{0})\cdot M_{1}+(X_{2}-X_{0})\cdot M_{2}+\ldots +(X_{n}-X_{0})\cdot M_{n}}$
  ${\displaystyle 0=(X_{1}\cdot M_{1}+X_{2}\cdot M_{2}+\ldots +X_{n}\cdot M_{n})-X_{0}\cdot (M_{1}+M_{2}+\ldots +M_{n})}$
  ${\displaystyle X_{0}\cdot (M_{1}+M_{2}+\ldots +M_{n})=X_{1}\cdot M_{1}+X_{2}\cdot M_{2}+\ldots +X_{n}\cdot M_{n}}$
  ${\displaystyle X_{0}={\frac {X_{1}\cdot M_{1}+X_{2}\cdot M_{2}+\ldots +X_{n}\cdot M_{n}}{M_{1}+M_{2}+\ldots +M_{n}}}}$

In our example, the values of mu correspond to the masses, and the values of X to location of the masses (mu, however, only 'corresponds to the masses' if the initial 'mass' of the output functions are all the same/equivalent. If they are not the same, i.e. some are narrow triangles, while others maybe wide trapezoids or shouldered triangles, then the mass or area of the output function must be known or calculated. It is this mass that is then scaled by mu and multiplied by its location X_i).

This system can be implemented on a standard microprocessor, but dedicated fuzzy chips are now available. For example, Adaptive Logic INC of San Jose, California, sells a "fuzzy chip", the AL220, that can accept four analog inputs and generate four analog outputs. A block diagram of the chip is shown below:

              +---------+                              +-------+
 analog --4-->| analog  |                              | mux / +--4--> analog
   in         |   mux   |                              |  SH   |        out
              +----+----+                              +-------+
                   |                                       ^
                   V                                       |
            +-------------+                             +--+--+
            | ADC / latch |                             | DAC |
            +------+------+                             +-----+
                   |                                       ^
                   |                                       |
                   8         +-----------------------------+
                   |         |                             |
                   |         V                             |
                   |   +-----------+      +-------------+  |
                   +-->| fuzzifier |      | defuzzifier +--+
                       +-----+-----+      +-------------+
                             |                   ^
                             |  +-------------+  |
                             |  |    rule     |  |
                             +->|  processor  +--+
                                | (50 rules)  |
                                +------+------+
                                       |
                                +------+------+
                                |  parameter  |
                                |    memory   |
                                |   256 x 8   |
                                +-------------+

    ADC:  analog-to-digital converter
    DAC:  digital-to-analog converter
    SH:   sample/hold