1. Open-loop: AERL style, we shut down the tracker for a short
period
of time, measure the open-circuit voltage, and then track to 80% of
that voltage. The 80% is adjustable, but seems to be about right for a
good panel. This works well when the panels are good, but falls over
horribly in the case where bypass diodes conduct.

2. P and O: Perturb and Observe, which is a hill-climbing algorithm.
You perturb the panel voltage in one direction, and if the power goes
down, you perturb it back the other direction. If the power goes up,
you keep going in the same direction. This is the DriveTek style of
algorithm. I'm not familiar with the present DriveTek software, but
the old software directly controlled the PWM, which ended up being a
little unstable in rapidly changing sunlight. This has the annoying
feature where it can get stuck on a local minimum (e.g. if a diode is
kicking in, the power-voltage curve gets more than one "lump", which
means it can get stuck in the wrong spot). To speed the start-up
process, our version of this algorithm starts at 80% of the panel
voltage.

3. Incremental conductance: I haven't actually implemented this, but
it makes a lot of sense -- there's a nice mathematical check you can
do to see if you're on the maximum power point, and if you are, you
stop perturbing. It's cool, because it means you don't end up
perturbing the whole time (which means you're never _actually_ on the
maximum power point).

4. Advanced incremental conductance: I haven't implemented this
either. Basically the same as incremental conductance, but changing
the step size based on the rate at which the power is changing. If the
power is changing quickly as you move the setpoint, then you want to
move faster (since you're clearly a long way away from the MPP), but
if the power changes slowly, you move slower.

There are academic papers on the last two. I've also seen different
algorithms based on sliding windows, as well as the ripple from the
switching converter (which won't work in this case because it's
switching at 20kHz, which is too fast).

What sort of algorithms have people looked at? Has anyone developed
something themselves which they found to work? Has anyone out there
compared algorithms? If so, how did you do it effectively?