A new control method

Hi :

I am a new group member. In this letter, A new control method which is
similar to the inverse dynamic (a nonlinear control method) will be
described simply. If anybody has touched or researched this method, or
has other different solutions, please give me the suggestions. I just
want to find friends.

                 1. A brief primal concepts :

Given a linear discrete-time system model in the z-domain type

   Y(z) b0 + b1/z + b2/(z^2) + ... + bm/(z^m)
  ------ = ---------------------------------------
   U(z) 1 + a1/z + a2/(z^2) + ... + an/(z^n)

Where y() is the system output and u() is the control signal.
At some time k, The time-series relation between outputs and
control is

   y(k) + a1*y(k-1) + a2*y(k-2) + ... + an*y(k-n) =
          b0*u(k) + b1*u(k-1) + b2*u(k-2) + ... + bm*u(k-m)

i.e.

   y(k) = b0*u(k) + b1*u(k-1) + ... + bm*u(k-m) -
                    a1*y(k-1) - ... - an*y(k-n) (1)

If this time is k, then we can forecast the future outputs y(k+1),
y(k+2) , ... through equation (1),

   y(k+1) = b0*u(k+1) + b1*u(k) + ... + bm*u(k-m+1) -
            a1*y(k) - a2*y(k-1) - ... -an*y(k-n+1)
   y(k+2) = b0*u(k+2) + b1*u(k+1) + ... + bm*u(k-m+2) -
            a1*y(k+1) - a2*y(k) - ... - an*y(k-n+2)
             .
             .
             .
   y(k+i) = b0*u(k+i) + b1*u(k+i-1) + ... + bm*u(k-m+i) -
            a1*y(k+i-1) - a2*y(k+i-2) - ... - an*y(k-n+i)

Where y(k+1), y(k+2), ..., y(k+i) and u(k+1), u(k+2), ..., u(k+i)
are all unknown, move the unknown outputs to the left by recursive
method,

   y(k+1) = b0*u(k+1) + b1*u(k) + ... + bm*u(k-m+1) -
            a1*y(k) - a2*y(k-1) - ... -an*y(k-n+1)
   y(k+2) = b0*u(k+2) + (b1-a1*b0)*u(k+1) + (b2-a1*b1)*u(k) + ...
            + bm*u(k-m+1) + (a1*a1-a2)*y(k) + (a1*a2-a3)*y(k-1) +
            ... - a1*an*y(k-n+1)
          .
          .
          .
   y(k+i) = b0*u(k+i) + b1'*u(k+i-1) + ...... +
            a1'*y(k) + .... + an'*y(k-n+1)

Where u(k), u(k-1), ..., u(k-m+1), and y(k), y(k-1), ..., y(k-n+1)
are known because this time is k, so

   y(k+1) = b0*u(k+1) + c1
   y(k+2) = b0*u(k+2) + (b1-a1*b0)*u(k+1) + c2
          .
          .
   y(k+i) = b0*u(k+i) + b1'*u(k+i-1) + ... + b(i-1)'* u(k+1) + ci

c1, c2, ..., ci are known, arranging these euqation in matrices

   / y(k+1) \ / u(k+1) \
   > y(k+2) | | u(k+2) |
   > . | = T * | . | + C
   > . | | . |
   \ y(k+i) / \ u(k+i) /

Where T is an i by i coefficient matrix, C is equal to [c1,c2,..,ci]'.
If n' <= i and n' > 0, the following equation can be picked out

   / y(k+i-n') \ / u(k+1) \
   > y(k+i-n'+1) | | u(k+2) |
   > . | = T' * | . | + C'
   > . | | . |
   \ y(k+i) / \ u(k+i) / (2)

T' is the submatrix of T and (n'+1) by i, C' is the subvector of C and
its length is (n'+1).

Consider the basic step-response control, the system outputs
are always desired to approximate a fixed reference. On the
steady state, the system outputs are equal to the reference
and the control signals are usually kept at a fixed value.
Realizing the relation between the future system outputs
and the control signals, we can obtain an optimal control signal
to make the future outputs approximate the reference (stable)
and the control signal approximate a fixed value (finite energy).

A error function is defined as follows to get the optimal control
signal. (Let the refrence be r(k) at time k.)

       / y(k+i-n') \ / r(k) \
       > y(k+i-n'+1) | | r(k) |
       > . | | . |
       > . | | . | 1+a1+...+an
   E = | y(k+i) | - | r(k) | us = -------------- * r(k)
       > u(k+i-m') | | us | b0+b1+...+bm
       > u(k+i-m'+1) | | us |
       > . | | . |
       > . | | . |
       \ u(k+i) / \ us / (3)
and

       n' = | i-1 if i<= n m' = | i-1 if i <= m
            > n if i > n | m if i > m

Substitute equation (2) into (3), the relation between the error
function and the control signal is

                                         / r(k) \
                                         > r(k) |
                  / u(k+1) \ | . |
       / T' \ | u(k+2) | / C \ | . |
   E = | | * | . | + ( | | - | r(k) | )
       \ 0, I / | . | \ 0 / | us |
                  > . | | us |
                  \ u(k+i) / | . |
                                         > . |
                                         \ us / (4)

Where I is an unit matrix, and 0's are zero matrices.
Minimize (E'*E) by the least-square method (QR decomposition as
usual), the corresponding control signal u(k+1), u(k+2), ...,
u(k+i) is the optimal values which makes future outputs y(k+1),
y(k+2), ..., y(k+i) approximate r(k) and the control signal
approximate a fixed value us as possible. However, only u(k+1) is
selected to apply to the controlled system at time k+1, and the same
approaches is reviewed at the following time to get the optimal u(k+2).

In equation (4), variable i is called as CONTROLLER ORDER, which is
suggested to be limited from 1 to (n+m+1). When i=(n+m+1), the minimum
(E'*E) is zero and the stability of the controlled system is sure.

Besides, a parameter w is jointed into the error function to improve
the output performance, which is called WEIGHT.

       / w*y(k+i-n') \ / w*r(k) \
       > w*y(k+i-n'+1) | | w*r(k) |
       > . | | . |
       > . | | . |
   E = | w*y(k+i) | - | w*r(k) |
       > u(k+i-m') | | us |
       > u(k+i-m'+1) | | us |
       > . | | . |
       > . | | . |
       \ u(k+i) / \ us /

The weight is usually greater than one except some nonminimum-phase
systems. When i=1 and w=infinity, this method is equal to the inverse
dynamic.

                         2. Remarks

1. The concepts of this method is based on SYSTEM FORECAST. The most
    of human control behaviors is also based on the similar mode,
    and we call that 'EXPERIENCE'.

2. This method provides very rapid analyses for any control system,
    whether stable or unstable, minimumum-phase or nonminimum-phase.

3. The robustness is worse under model noise, an improvement is to
    select new control signal du, du is defined as follows :
            du(k) = u(k) - u(k-1)
    in the z-domain type
            dU(z) = U(z) - U(z)/z
    Through the new control signal, the steady-state error due to model
    noise is deleted.

4. An interesting skill : for varying references, if the future
    references are known at every sample, the error function can be
    modified to
           / y(k+i-n') \ / r(k+i-n') \
           > y(k+i-n'+1) | | r(k+i-n'+1)|
           > . | | . |
           > . | | . | 1+a1+...+an
       E = | y(k+i) | - | r(k+i) | us(j) = -------------- * r(j)
           > u(k+i-m') | | us(k+i-m') | b0+b1+...+bm
           > u(k+i-m'+1) | |us(k+i-m'+1)|
           > . | | . |
           > . | | . |
           \ u(k+i) / \ us(k+i) /
    This skill results in a null-phase-delay response.

5. This control method is easy to link an on-line system-identification
    implement, an adaptive control system can be built up to retrieve
    the worse robustness.

6. For multi-input-multi-output systems, a very enormous matrix can be
    foresight, and the null diagonal elements may be existed in the QR
    decomposition.

                                        Bill Chen (Kuo-Feng Chen)
                                      of NCTU in Taiwan.

[From Rick Marken (920608 10:30)]

This is to Bill Chen.

Welcome to CSGNet. I have a couple of quesions about your post before
I try to tackle the math (I don't think you'll find too many of us
on CSGNet to be real familiar with many of the common tools of control
engineering -- like Laplace trnasforms, etc. We tend to do most of our
work with computer simulation and we are mostly interested in what
variables living systems control -- but, of course, we are also interested
in how they control them.)

I am currently working on a paper which describes a new method of aiding
the human operator in a control task. So I want to understand your
method. It looks to me you are using a type of predictive display system --
where the person is controlling a cursor relative to the a computed
version of the target. The idea, I think, is to get the person to respond
to this target (rather than the real target) so that their response will
be "optimal" and make the actual difference between operator response
and actual target be minimized).

Anyway, in order to see if I'm right I have to understand what you are
referring to by some terminology -- CSG terminology is often somewhat
different than that of engineering control theorists because we look
at the control situation a bit differently.

So, you say:

Where y() is the system output and u() is the control signal.
At some time k, The time-series relation between outputs and
control is

What do you consider the output signal and the control signal?
Consider the task to be compensatory tracking carried out by a
human subject (like keeping a cursor alighed with a fixed target).
The cursor position, c(t), depends on handle movements, h(t), and
disturbance, d(t), so c(t) = h(t)+d(t). Is h(t) the the output variable?
I think it must be. But what is the "control signal"? is it d(t) (which
determines the required value of h(t) that keeps the cursor on target)
or is it the difference between target position (T) and cursor position,
what is sometimes called the error input e(t) = T-c(t)?

Consider the basic step-response control, the system outputs
are always desired to approximate a fixed reference.

What is the fixed reference for in the compensatory tracking task --
for the difference T-c(t)? Who "desires" this fixed reference --the
subject or the observer of the subject?

On the
steady state, the system outputs are equal to the reference
and the control signals are usually kept at a fixed value.

If system outputs are h(t) then the only reference they should be equal
to is d(t). So this would mean that the reference is to have system
outputs equal to control signals?

It is important to know what you think is a "reference" and who sets it,
because you say:

An interesting skill : for varying references, if the future
   references are known at every sample, the error function can be
   modified to
          / y(k+i-n') \ / r(k+i-n') \
          > y(k+i-n'+1) | | r(k+i-n'+1)|
          > . | | . |
          > . | | . | 1+a1+...+an
      E = | y(k+i) | - | r(k+i) | us(j) = -------------- * r(j)
          > u(k+i-m') | | us(k+i-m') | b0+b1+...+bm
          > u(k+i-m'+1) | |us(k+i-m'+1)|
          > . | | . |
          > . | | . |
          \ u(k+i) / \ us(k+i) /
   This skill results in a null-phase-delay response.

I presume that the r() are the reference values at different times.
How do you know what these values are? Are they really the values that
someone thinks that the subject SHOULD maintain as their reference
for the difference between output and control signal?

I want to understand this because one of the main virtues of my own
approach to aiding a controller is that it works even though the
controller him/her self changes his or her OWN reference for the
difference between output and control signal in an unpredictable
manner.

Best regards

Rick

···

**************************************************************

Richard S. Marken USMail: 10459 Holman Ave
The Aerospace Corporation Los Angeles, CA 90024
E-mail: marken@aero.org
(310) 336-6214 (day)
(310) 474-0313 (evening)