Seeking suggestions for synchronizing the positions of 2 linear actuators

[rubidium]

Consider that I have 2 linear actuators that are attached to the 2 free corners of a rectangular hinged frame, so that extension/contraction of the actuators will change the angle that the plane of the frame makes with the local horizontal. In operation, the frame will likely be supporting varying heavy loads (hundreds of pounds), and the objective is to synchronize the actuators so that the frame angle can be varied without "twisting".

At present, I have a microcontroller-based circuit that drives a single actuator via a pair of Infineon BTS-7960 half-bridge chips, and also tracks actuator position using a pair of Hall sensors internal to the actuator. This circuit works perfectly for a single actuator. But now I need to drive two actuators in unison such that the position of one doesn't get ahead or lag behind the other.

One obvious choice is to set up a closed-loop configuration using the respective Hall sensors of the two actuators, and implement a PID algorithm to adjust the actuator speeds based on any difference in measured positions, thus ensuring they move together. Those speeds can easily be controlled by driving the half-bridge chips with PWM. But that begs a couple of questions:
1. How can one select PID gains necessary for stable operation in situations where the load experienced by the actuators will likely vary? I know that there are a variety of tuning algorithms that are based upon "mapping out" the system dynamics in response to step changes in the controlled variable. But that would assume that the system dynamics remains the same throughout the operating regime of the system - which I'm not sure will ever be the case in this situation.
2. Should I use a master-slave configuration, where one actuator is arbitrarily considered a master and dictates the movement, while the other the other (slave) is the one that's controlled to stay in sync with it? If that were the case, I would suspect that the master should be run at some PWM duty factor of, say, 0.7 to that the duty factor of the slave has sufficient latitude to speed up or slow down as needed.

So I'm soliciting any thoughts from folks who might have done something like this. Thanks in advance.
Jim

[moffy]

Had a similar problem controlling the speed of a locomotive/train while it was being loaded with coal, the weight was constantly changing, I chose the simple solution of choosing a gain that was safe for all power to weight ratios, but of course that became under damped for heavy trains. I left the business but later was able to test a competitors speed controller, Westinghouse WA, and the algorithm was adaptive, they were measuring the loop gain and compensating on the fly, it was very effective from what I could see of my limited tests.
Just to mention, my slow algorithm was very effective at controlling speed, we instrumented a train and measured its speed while loading and the speed was effectively flat. Sometimes simple works well.

[Doctorandus_P]

It's common to have two nested PID loops. The outer loop will then be for the position, while the inner will be for motor voltage. I think you can even nest a 3rd loop for the motor current. With nested loops you get better controlability. For most (simple) motor control applications you can skip the Differentiator part, and this makes the loop easier to tune.

It's also possible to use a mechanical contraption. For example with a torque bar and two cords (chains, gear+ rack) connected connected to the actuators, this will balance the load between the actuators. The "fastest" will have to deliver more torque, which will slow the motor down (and help the slowest) This can also be done with a single rope and a bunch of pulley's

[MarkT]

I would suggest separating the control into two parallel PI or PID loops, one for the common-mode position, one for the difference-mode position.  Then the two actuators are dirven by the sum and difference of the loop outputs respectively.  This means you can tune the loops differently which might be handy (or maybe not).

This topology has the advantage of being symmetrical - simply chaining one control loop from the other means one actuator will always lag behind the other, whereas symmetrical control will give the best results I hope.

[rubidium]

Yes - good suggestions all around. After further thought, I too convinced myself that some form of "symmetric" multi-loop control approach would be better than a "master-slave" single-loop approach. I also need to incorporate a strategy to disengage control once a certain acceptable degree of position equalization between the two actuators occurs, concurrent with achieving the overall commanded position to the desired accuracy.  I want to avoid having these actuators endlessly "jiggling" back-and-forth by minute amounts, similar to what you might have in a temperature control situation.

BTW, what is being adjusted in this activity is the common angle (referenced to the local horizontal) of multiple engine-driven propellers on competitive high-speed boats. Speeds up to 200MPH, developed at power levels of several thousand horsepower, requires thrust to be delivered to the water at varying angles in order to safely maintain trim under very dynamic conditions. These actuators are powerful and responsive enough and, with the associated circuitry, do the job very well with single-engine implementations. But with multiple engines mounted to a common frame, we want to go with a dual actuator set up.

Thanks for the constructive comments.
Jim

[PCB.Wiz]

BTW, what is being adjusted in this activity is the common angle (referenced to the local horizontal) of multiple engine-driven propellers on competitive high-speed boats. Speeds up to 200MPH, developed at power levels of several thousand horsepower, requires thrust to be delivered to the water at varying angles in order to safely maintain trim under very dynamic conditions. These actuators are powerful and responsive enough and, with the associated circuitry, do the job very well with single-engine implementations. But with multiple engines mounted to a common frame, we want to go with a dual actuator set up.

Wow, that's certainly quite dynamic.

Are the sensors here quadrature encoders with some steps  / mm ? 
Is there any absolute position sense ?

I also need to incorporate a strategy to disengage control once a certain acceptable degree of position equalization between the two actuators occurs, concurrent with achieving the overall commanded position to the desired accuracy.  I want to avoid having these actuators endlessly "jiggling" back-and-forth by minute amounts, similar to what you might have in a temperature control situation.

So you do not need to try to adjust for waves, just travel to some set angle, seek and then lock ?