Características de los algoritmos de rendezvous propuestos en la literatura

State feedback is a commonly used approach for multiple-input-multiple-output systems due to its relative simplicity and inherent stabilising nature [153]. This uses the feedback law (57), where K is a constant matrix to be calculated. For this system, the output m is required to drive the control signal, not z. m can be factored into by using the transform relationship (50).

𝒖(𝒕) = −𝐾𝒛(𝒕) (57)

𝒖(𝒕) = −𝐾𝑇𝒎(𝒕) (58)

The steady state error when a step disturbance is applied can be calculated by considering the point at which the derivative of z is zero, which is given by (59). The resultant steady state output error mss is given by (60)12. As is expected, there is no steady state error when there is no disturbance.

12_{K, 𝐵ï}

ƒand 𝐵ïˆ are all rectangular so do not strictly have an inverse. However, unlike with the pseudoinverse, the equations can be solved using similar methods as for square matrices, and so the superscript -1 _{is still used.}

𝟎 = −𝐵ï_ƒ𝐾𝒛_𝒔𝒔+ 𝒃(_𝟐𝑑 (59)

𝒎𝒔𝒔= 𝑇»𝐾•ƒ𝐵ƒ𝒃(𝟐𝑑 (60) Two common methods of designing a state feedback regulator are pole placement and LQR [124]. Both methods are considered in Submission 3, but pole placement was carried forward as the tuning parameters are more intuitive for this system than LQR and it is easier to ensure the cells reach EOB simultaneously. Pole placement is used to calculate a gain matrix such that a desired vector of poles is achieved for the closed loop system. The time constant of a pole is obtained using (61), so it is straightforward to select a pole based on the time available for balancing. In their standard form, both methods assume there is no disturbance (or that the disturbance has a mean of zero), which means there will be steady state error in the control solution. As noted above, three methods for accounting for the disturbance were considered in Submission 3: integral action, H-infinity output feedback, and a disturbance gain. These were not implemented experimentally and so are not discussed here.

𝜏 = −1

𝜆 (61)

Iterative algorithms are available [155] to find K such that each state has the desired pole. However, for this case, it can be simplified. Two important aspects of the balancing system model are that the A matrix is zero and the desired poles are the same for each cell (so they will all reach the mean SOC simultaneously). The closed loop dynamics are given by (62) and the poles are found by solving the eigenvalue problem in (63). The points above simplifies the problem considerably compared to many other linear state space systems, and (64) is the most straightforward solution to (63). In this case λ is a scalar and real, and should be negative to ensure stability.

𝒛̇(𝑡) = −𝐵ï_ƒ𝐾𝒛(𝑡) (62)

|−𝐵ïƒ𝐾 − 𝜆𝐼| = 0 (63)

𝐵ï_ƒ𝐾 = − 𝜆𝐼 (64)

The steady state error can be calculated using (65), which substitutes (64) into (60). This shows that a slower balancing pole results in a larger steady state error. As such the fastest pole should be chosen that the balancing hardware is capable

𝒎_𝒔𝒔= −1

𝜆𝑇»𝐼𝒃(𝟐𝑑 = − 1

𝜆𝑀𝒃𝒅𝑑 (65)

The most direct way of obtaining K is to solve (64) by finding the inverse of 𝐵ï_ƒ to give (66). Since it is rectangular it does not have an inverse: there are essentially

N unknowns but only N-1 equations, making it an under-determined system. As derived and discussed within Submission 3, there are two main ways of solving this: a least-squares solution, and singular value decomposition (SVD). The least- squares solution results in the K matrix containing a row of zeros, making the balancing input corresponding to that row redundant. The SVD approach distributes the control action across all inputs. MATLAB’s pole-placement algorithm place [156], which calculates a robust solution resulting in a non-zero

K matrix, calculates the same matrix as the SVD approach.

𝐾 = 𝐵ï_ƒ•ƒ_{(− 𝜆𝐼) (66)}

For these solutions, the inverse of Bc and its associated matrices can be stored as a static matrix (and periodically updated if the elements of Bc change from the SOH estimation). K can then be simply calculated based on the desired pole value. This pole can be adjusted based on the estimated time until EOD or EOC, and updated regularly because of the simple calculation required to obtain the new K. These methods are generally reliable solutions to obtain since they are based around well-known and robust matrix techniques rather than more complex algorithms. It is also clear that the gain is proportional to the chosen pole, which means if the pole results in excessive balancing currents, it can easily be adjusted to bring the currents to within a feasible range.

The two methods show how there can be multiple K matrices which produce the same poles. Using the least squares method means that one cell will also be at zero balancing current, which offers redundancy in the event of one balancing channel failing. The SVD solution distributes the control effort across all of the cells, which means that for a given pole, the maximum balancing current will be lower and there is less chance of saturating one of the control inputs.

The pole can be chosen based on the estimate of time to EOD. Alternative, the fastest pole which does not saturate any inputs can be found. A simple bisection

algorithm can be used to search for the pole. This uses the current pole to calculate the state feedback matrix. This, along with the initial m vector, is used to calculate the initial balancing currents. If any of the currents are outside of the limits imposed by the hardware, the pole is decreased for the next iteration. If none of the currents are above 99% of the limit, then the pole could be faster and so is increased. If neither of these conditions are met, then a suitable pole has been found, for which at least one of the cells is set to balance at its maximum value. Example code to demonstrate the algorithm is given in Figure 37.

lambdaMin = -1/10000; %less likely to cause 100%duty

lambdaMax = -1/10; %more likely to cause 100% duty

while nIter < nIterMax % avoid searching indefinitely nIter = nIter + 1; % count number of iterations

lambda = (lambdaMax+lambdaMin)/2; %update lambda as halfway between max and min

% ...

%Here, K is solved for using lambda value % ...

u0 = K*T*m0; %the initial current requested by controller

if any(u0 < uMin || u0 > uMax)

%Input saturated: reduce the maximum to give a slower pole next iteration.

lambdaMax = lambda;

elseif (max(u0) < 0.99*uMax) || (min(u0) > 0.99*uMin) %pole is too slow: no inputs are at the maximum. Increase the

%minimum so next iteration a faster pole is used. lambdaMin = lambda;

else

break; %a suitable pole has been found.

end

Figure 37: Example code for bisection algorithm