196 lines
7.6 KiB
Matlab
196 lines
7.6 KiB
Matlab
% ------------------------------------------------------------------------
|
|
% The script performs drive gain identification of UR10E robot.
|
|
% To do that several methods were used: total least squares approach;
|
|
% ordinary least squares approach; and ordinary least squares with physical
|
|
% feasibility constraints that is solved using semidefinite programming
|
|
% -----------------------------------------------------------------------
|
|
clc; clear all; close all;
|
|
|
|
% ------------------------------------------------------------------------
|
|
% Load raw data and procces it (filter and estimate accelerations).
|
|
% Several trajectories were recorded for unloaded and loaded cases.
|
|
% Different combination of trajectories provide slighlty different results.
|
|
% Nonetheless, during validation they provide the more or less the same
|
|
% result. So, any unloaded trajectory from the given list can be chosen
|
|
% ------------------------------------------------------------------------
|
|
% unloadedTrajectory = parseURData('ur-20_02_12-50sec_12harm.csv', 355, 5090);
|
|
% unloadedTrajectory = parseURData('ur-20_01_31-unload.csv', 300, 2623);
|
|
unloadedTrajectory = parseURData('ur-20_02_19_14harm50sec.csv', 195, 4966);
|
|
|
|
unloadedTrajectory = filterData(unloadedTrajectory);
|
|
|
|
loadedTrajectory = parseURData('ur-20_02_19_14harm50secLoad.csv', 308, 5071);
|
|
loadedTrajectory = filterData(loadedTrajectory);
|
|
|
|
% ------------------------------------------------------------------------
|
|
% Generate Regressors based on data.
|
|
% Here we generate base regressor, thta is obtained form the full regressor
|
|
% by multiplying it by the mapping from full standard paramters
|
|
% to base parametrs using numerical approach based on QR decomposition
|
|
% ------------------------------------------------------------------------
|
|
% Load matrices that map standard set of paratmers to base parameters
|
|
load('baseQR.mat'); % load mapping from full parameters to base parameters
|
|
E1 = baseQR.permutationMatrix(:,1:baseQR.numberOfBaseParameters);
|
|
m_load = 2.805;
|
|
|
|
% Constracting regressor matrix for unloaded case
|
|
Wb_uldd = []; I_uldd = [];
|
|
for i = 1:1:length(unloadedTrajectory.t)
|
|
Y_ulddi = regressorWithMotorDynamics(unloadedTrajectory.q(i,:)',...
|
|
unloadedTrajectory.qd_fltrd(i,:)',...
|
|
unloadedTrajectory.q2d_est(i,:)');
|
|
|
|
Yfrctni = frictionRegressor(unloadedTrajectory.qd_fltrd(i,:)');
|
|
Ybi_uldd = [Y_ulddi*E1, Yfrctni];
|
|
|
|
Wb_uldd = vertcat(Wb_uldd, Ybi_uldd);
|
|
I_uldd = vertcat(I_uldd, diag(unloadedTrajectory.i_fltrd(i,:)));
|
|
end
|
|
|
|
% Constracting regressor matrix for loaded case
|
|
Wb_ldd = []; Wl = []; I_ldd = [];
|
|
for i = 1:1:length(loadedTrajectory.t)
|
|
Y_lddi = regressorWithMotorDynamics(loadedTrajectory.q(i,:)',...
|
|
loadedTrajectory.qd_fltrd(i,:)',...
|
|
loadedTrajectory.q2d_est(i,:)');
|
|
|
|
Yfrctni = frictionRegressor(loadedTrajectory.qd_fltrd(i,:)');
|
|
Ybi_ldd = [Y_lddi*E1, Yfrctni];
|
|
|
|
Yli = load_regressor_UR10E(loadedTrajectory.q(i,:)',...
|
|
loadedTrajectory.qd_fltrd(i,:)',...
|
|
loadedTrajectory.q2d_est(i,:)');
|
|
|
|
Wb_ldd = vertcat(Wb_ldd, Ybi_ldd);
|
|
Wl = vertcat(Wl,Yli);
|
|
I_ldd = vertcat(I_ldd, diag(loadedTrajectory.i_fltrd(i,:)));
|
|
end
|
|
Wl_uknown = Wl(:,1:9);
|
|
Wl_known = Wl(:,10); % mass of the load is known
|
|
|
|
|
|
%% Using total least squares
|
|
% TLS provides rather bad results. Even normilizing by mass and using
|
|
% weighting does not help to improve results
|
|
Wb_tls = [I_uldd -Wb_uldd zeros(size(I_uldd,1), size(Wl,2));
|
|
I_ldd -Wb_ldd -Wl_uknown -Wl_known*m_load];
|
|
|
|
% SVD decompostion of Wb_tls to solve total least squares
|
|
[~,~,V] = svd(Wb_tls,'econ');
|
|
% Scaling of the solution
|
|
lmda = 1/V(end,end);
|
|
pi_tls = lmda*V(:,end);
|
|
% drive gains
|
|
drvGainsTLS1 = pi_tls(1:6)
|
|
|
|
% Finding weighting matrix, joint by joint
|
|
G = zeros(6);
|
|
for i = 1:6
|
|
Wib_tls = Wb_tls(i:6:end,:);
|
|
[~,Si,Vi] = svd(Wib_tls,'econ');
|
|
sgmai = Si(end,end)/sqrt((size(Wib_tls,1)-rank(Wib_tls)));
|
|
G(i,i) = 1/sgmai^2;
|
|
end
|
|
% Weighting observation matrix
|
|
for i = 1:6:size(Wb_tls,1)
|
|
Wb_tls(i:i+5,:) = G*Wb_tls(i:i+5,:);
|
|
end
|
|
[~,~,V] = svd(Wb_tls,'econ');
|
|
lmda = 1/V(end,end);
|
|
pi_tls = lmda*V(:,end);
|
|
drvGainsTLS2 = pi_tls(1:6)
|
|
|
|
|
|
%% Identification of parameters including drive gains
|
|
% Although according to Handbook of robotics and papers of Gautier odinary
|
|
% least squares has correlated noise for correct drive gain estimation
|
|
% it provides good results. Weighted least square does not improve the
|
|
% result.
|
|
Wb_ls = [I_uldd -Wb_uldd zeros(size(I_uldd,1), size(Wl_uknown,2));
|
|
I_ldd -Wb_ldd -Wl_uknown];
|
|
|
|
Yb_ts = [zeros(size(I_uldd,1),1); Wl_known*m_load];
|
|
|
|
% Compute least squares solution
|
|
pi_ls = ((Wb_ls'*Wb_ls)\Wb_ls')*Yb_ts;
|
|
drvGainsOLS1 = pi_ls(1:6)
|
|
|
|
|
|
G = zeros(6);
|
|
for i = 1:6
|
|
Wib_ls = Wb_ls(i:6:end,:);
|
|
Yib_ls = Yb_ts(i:6:end);
|
|
sgmai_sqrd = norm(Yib_ls - Wib_ls*pi_ls,2)^2/(size(Wib_ls,1)-rank(Wib_ls));
|
|
G(i,i) = 1/sqrt(sgmai_sqrd);
|
|
end
|
|
G = diag([0.05 1 1 1 1 1]);
|
|
|
|
for i = 1:6:size(Wb_ls,1)
|
|
Wb_ls(i:i+5,:) = G*Wb_ls(i:i+5,:);
|
|
Yb_ts(i:i+5) = G*Yb_ts(i:i+5);
|
|
end
|
|
pi_tot = ((Wb_ls'*Wb_ls)\Wb_ls')*Yb_ts;
|
|
drvGainsOLS2 = pi_tot(1:6)
|
|
|
|
|
|
%% Set-up SDP optimization procedure
|
|
% Provides more or less the same result as OLS but with physical
|
|
% consistencty. The drive gains estimated using this appraoch is further
|
|
% used for indetification of inertial parameters
|
|
drv_gns = sdpvar(6,1); % variables for base paramters
|
|
pi_load_unknw = sdpvar(9,1); % varaibles for unknown load paramters
|
|
pi_frctn = sdpvar(18,1);
|
|
pi_b = sdpvar(baseQR.numberOfBaseParameters,1); % variables for base paramters
|
|
pi_d = sdpvar(26,1); % variables for dependent paramters
|
|
|
|
% Bijective mapping from [pi_b; pi_d] to standard parameters pi
|
|
pii = baseQR.permutationMatrix*[ eye(baseQR.numberOfBaseParameters), ...
|
|
-baseQR.beta; ...
|
|
zeros(26,baseQR.numberOfBaseParameters), ...
|
|
eye(26) ]*[pi_b; pi_d];
|
|
|
|
% Feasibility contrraints of the link paramteres and rotor inertia
|
|
cnstr = [drv_gns(1)>10]; % strong constraint on minimum value of K1
|
|
for i = 1:11:66
|
|
link_inertia_i = [pii(i), pii(i+1), pii(i+2); ...
|
|
pii(i+1), pii(i+3), pii(i+4); ...
|
|
pii(i+2), pii(i+4), pii(i+5)];
|
|
|
|
frst_mmnt_i = vec2skewSymMat(pii(i+6:i+8));
|
|
|
|
Di = [link_inertia_i, frst_mmnt_i'; frst_mmnt_i, pii(i+9)*eye(3)];
|
|
cnstr = [cnstr, Di>0, pii(i+10)>0];
|
|
end
|
|
|
|
% Feasibility constraints on the load paramters
|
|
load_inertia = [pi_load_unknw(1), pi_load_unknw(2), pi_load_unknw(3); ...
|
|
pi_load_unknw(2), pi_load_unknw(4), pi_load_unknw(5); ...
|
|
pi_load_unknw(3), pi_load_unknw(5), pi_load_unknw(6)];
|
|
load_frst_mmnt = vec2skewSymMat(pi_load_unknw(7:9));
|
|
Dl = [load_inertia, load_frst_mmnt'; load_frst_mmnt, m_load*eye(3)];
|
|
|
|
cnstr = [cnstr, Dl>0];
|
|
|
|
% Feasibility constraints on the friction prameters
|
|
for i = 1:6
|
|
cnstr = [cnstr, pi_frctn(3*i-2)>0, pi_frctn(3*i-1)>0];
|
|
end
|
|
|
|
% Defining objective function
|
|
t1 = [zeros(size(I_uldd,1),1); -Wl(:,end)*m_load];
|
|
|
|
t2 = [-I_uldd, Wb_uldd, zeros(size(Wb_uldd,1), size(Wl,2)-1); ...
|
|
-I_ldd, Wb_ldd, Wl(:,1:9) ];
|
|
|
|
obj = norm(t1 - t2*[drv_gns; pi_b; pi_frctn; pi_load_unknw]);
|
|
|
|
% Solving sdp problem
|
|
sol = optimize(cnstr,obj,sdpsettings('solver','sdpt3'));
|
|
|
|
% Getting values of the estimated patamters
|
|
drvGainsSDP = value(drv_gns)
|
|
|
|
%% Saving obtained drive gains
|
|
drvGains = drvGainsSDP;
|
|
filename = 'driveGains.mat';
|
|
save(filename,'drvGains') |