Joerg said:
Hello Folks,
We need to lock onto one side of a sharp but moving resonance similar to
a Fabry-Perot dip. Sharp meaning around 10pm. Long story short, when
scooting the TEC via a ADN8831 chip it's tough to achieve regulation
without overshoot. IOW tuning the PID loop is a bear and the locking
mechanism overshoots the target which shall not happen in this case.
It's a DFB module (JDS and one from Sumitomo).
What is the fastest TEC tuning speed that the laser expert here have
achieved with those modules without "ringing"?
Of course it's possible to move 10C in a couple of seconds but when
checking how professional equipment such as the ILX Lightwave controller
is the lab does that it overshoots by a lot more than 1C and takes
several seconds to stabilize. They seem to really be stepping on it for
the derivative part which is ok in telco apps where you usually set the
wavelength once and then leave it there. In our case we must remain
agile. The total range we need is around 10C (hopefully...). A wee
overshoot of 0.1-0.2C would be ok but when tuning the PID loop towards
that goal the whole thing becomes like molasses.
ADI says: "The ADN8831 is a highly integrated solution for controlling
the TEC in a laser module used in optical communications systems."
So why should it work for you?
My laser expertise doesn't extend much beyond knowing to put on those
funny goggles before I defeat the interlock. But as a control guy, I
can tell you that just tuning a PID loop isn't going to get you the best
possible performance.
There are two reasons for this. First, any controller that features an
integrator is almost guaranteed to give you overshoot without the
careful application of clever feed-forward schemes or nonlinearities in
the controller. Second, while you can, in theory, achieve near-perfect
control of a second-order system using a PID with clever feed-forward,
thermal systems are, in general, continuous-state systems. So you may
not be able _at all_ to use a PID to do this, even _with_ clever
nonlinearities as well as clever feed-forward.
If this task can be accomplished with clever application of the PID
controller, the first thing you're going to have to do is to pitch that
chip. I'd suggest replacing it with the microcontroller of your choice,
so you don't have to stand on your head to implement the necessary
control rule in hardware and so you're not constrained by the hardware
when you need to change it -- but once you have a control rule in hand
you can certainly implement it with analog circuitry, should that be
your preference.
At any rate, you need a PID controller that looks just like any other
PID controller _except_ for two things. First, set the feed forward and
feedback gains separately for the proportional and differential stages,
such that
prop_term = k_pf * command - k_pb * output
diff_term = d/dt(k_df * command - k_db * output)
Second, instead of using the traditional integrator anti-windup that
just limits the state of the integrator to fixed values, use
output-based integrator limiting. This means you should choose an
output value to limit to, then adjust the integrator state to hold that
value. This is fully discussed in my book, and I'm feeling lazy today,
so I'll just refer you to pp 213 and 214, equation 8.40, and the
surrounding text (Tim Wescott, "Applied Control Theory for Embedded
Systems", Elsevier 2006). Using this sort of integrator limiting will
dramatically reduce, or completely eliminate, the overshoot from
integrator windup, at the cost of having a much slower 'tail' to the
response -- and there are things you can do about that tail.
There's a good chance that using these two techniques together will get
you close enough. Certainly they'll get you much closer than you are
now. If they don't then reflect on this:
In principal you want a controller that puts just the right input into
the plant so that the plant stops where you want and then doesn't move.
For a linear system the output of the controller will be a function of
your desired behavior* filtered by the inverse transfer function of the
plant. You can, in theory at least, generate this sort of result with a
linear discrete-state plant of arbitrary order by implementing a
controller of similar order to push it around. In practice you run into
trouble if you get too ambitious, because your plant model is rarely
kind enough to match what you think it is.
I have had some success in the past using systems that are largely feed
forward with just enough feedback to fix things up at the end of the
excursion. My results with this have been mixed, largely due to folks
not allowing enough time to fix all of the interesting 2nd- and 3rd-
order effects that pop up as soon as you address the 'main' problem. If
you really need this to work, however, and you can spare the development
time, it's a way to go.
* if you have realistic desires, which means not asking for anything
that the plant's going to filter out to any degree.
--
Tim Wescott
Wescott Design Services
http://www.wescottdesign.com
Posting from Google? See
http://cfaj.freeshell.org/google/
"Applied Control Theory for Embedded Systems" came out in April.
See details at
http://www.wescottdesign.com/actfes/actfes.html