State-space Control for Disturbance Rejection with Multiple Actuators

susheemg@gmail.com wrote:

State space design can be a great method for unifying a large complex
system design, but sometimes it can obscure essential features of a
design with nonlinear elements such as this one.  I suggest you draw out
a block diagram for understanding, even if you reduce the design to
state space for linear analysis.

You can drive the fast actuator with your beam error, and drive the slow
actuator with your fast actuator's position.  This will tend to put the
'primary' control on your fast actuator, and if you put an integrator in
the path of your slow actuator you'll insure that the fast actuator is
centered around zero.  Depending on your actuators and your input
(especially if your input has an appreciable ramp input) you may need to
put double integrators into one or both loop, making them type II.

If you have trouble with the slow actuator not moving out of the way
fast enough and you're not saturating it's drive then you aren't giving
it enough high-speed content in its drive.  You can correct this by
giving it some of the error signal from the fast actuator's loop,
suitably conditioned.  Done right this shouldn't change the stability
properties of the system (or may improve them), but should goose the
slow actuator into faster motion.

--

Tim Wescott
Wescott Design Services
http://www.wescottdesign.com

Posting from Google?  See http://cfaj.freeshell.org/google/

Do you need to implement control loops in software?
"Applied Control Theory for Embedded Systems" gives you just what it says.
See details at http://www.wescottdesign.com/actfes/actfes.html

I have discussed a similar problem before. The first step is compensating
process and controller transfer functions [F1(s)*F2(s)=K]. In practice you
have to limit the speed as well as the acceleration of your equipment using
jerk filter (3rd order) if you move the set point (target).

First try modeling just one control loop (2nd order). If you succeed then
consider trying the next simpler loop.

You can only approach control theory! But this is the only way to get good
results.

Compensation:
process transfer function:    Kp/(1+A1*s^1+A2*s^2)
controller transfer function: Kc*(1+B1*s^1+B2*s^2)

F1(s)*F2(s)=K=Kp*Kc

You will have the correct 1st and 2nd derivatives in your model.

I consider a DC amplifier as almost time-compensated. What happens if K is
jittering? A DC amplifier or a computer is capable of moving an 'actuator'
with very high speed internally.

But you must also filter your real actuator input if you move from theory to
practice. This makes things worse but it can't be done better otherwise your
actuator will be destroyd.

Yor model output should show speed and acceleration. It's most important!

See similar Problem:
http://home.arcor.de/janch/janch/_control/20070428-controldoc/

Remark:
v2 may be regarded as actuator input that must be filtered (2. or 3. order)
because of jittering.

--
Regards/Grüße    http://home.arcor.de/janch/janch/menue.htm
Jan C. Hoffmann  eMail aktuell: janch@nospam.arcornews.de
                 Microsoft-kompatibel/optimiert für IE7+OE7

Using F1(s)*F2(s)=K (K=1) and in series F3(s) I get an open loop

F(s)_open = F1(s)*F2(s)*F3(s)=K*F3(s)

In closed loop F(s)_closed = 1/[1 + 1/F(s)_open]

The solution can be improved using additional

- integral action
- increasing K as high as possible

in real closed loop.

I used process and controller transfer functions

F1(s) = Kp/(1 + A1*s + A2*s^2)
F2(s) = Kc*(1 + B1*s + B2*s^2)

A1 = B1 = 0.333
A2 = B2 = 0.00106

compensating.

F3(s) = 1 + 0.1*s + 0.003*s2 + 0.00003*s3

MATLAB should give you the same result.

See also for F1(s)*F2(s)*F3(s) open loop:
http://home.arcor.de/janch/janch/_news/20070501-susheem/

Closed Loop e.g. K0
1/[1 + 1/(100*F3(s))] will result in
staedy state error ~ 1%

That can be corrected using integral action.

--
Regards/Grüße    http://home.arcor.de/janch/janch/menue.htm
Jan C. Hoffmann  eMail aktuell: janch@nospam.arcornews.de
                 Microsoft-kompatibel/optimiert für IE7+OE7