mvblkb.m

控制系统计算机辅助设计——MATLAB语言与应用(源代码）

%MVBLKB   Builds up an appended state space system from
% SISO transfer function blocks   nX, dX
% MIMO transfer function blocks   numX, comdenX
% state space blocks  aX, bX, cX, dX
% SISO transfer function blocks   nXij , dXij
%      to be formed into a MIMO state space system.
%
% The three vectors  nblocks, mvnblks and ssnblks contain the
% values of X respectively for first three forms of block. The
% matrix tfnblks contains the information required for the last
% form. The first row of tfnblks contains the block numbers
% X for the SISO to MIMO blocks, the second row contains the 
% number of inputs, and the third row contains the number of
% outputs for each of the MIMO blocks to be built up from 
% SISO blocks.
%
% The final a,b,c,d  state space system is formed from the blocks 
% in the order of X. If any of the vectors is missing or empty it 
% is ignored. A scalar for nblocks is expanded to a vector.
%
% If the variable verbose == 1 more info is printed.

%	Dr M.P. Ford 13th September 1987
% Copyright (c) 1987 by GEC Engineering Research Centre & Cambridge Control Ltd
%       MR0007
%       MR0032

if exist('verbose')==1
   if verbose == 1
     mv_trace = 1;
     disp('MVBLKB')
   else
     mv_trace = 0;
   end
else
   mv_trace = 0;
end

%  Search for the vectors
if exist('nblocks')==1
   if length(nblocks)==1   % expand
      v_nblk=1:nblocks;
   else
      v_nblk=nblocks(:);
   end    % if length
   if mv_trace
     disp('  SISO transfer function block numbers (nblocks)')
     disp(v_nblk')
   end
else
   v_nblk=[];
   if mv_trace
     disp('  No SISO transfer function blocks (nblocks does not exist)');
   end
end
if exist('mvnblks')==1
   v_mvblk=mvnblks(:);
   if mv_trace
   disp(['  Common denominator MIMO tranfer',...
        ' function block numbers (mvnblks)'])
     disp(v_mvblk')
   end
else
   v_mvblk=[];
   if mv_trace
     disp(['  No common denominator MIMO transfer function blocks',...
           ' (mvnblks does not exist)']);
   end
end
if exist('ssnblks')==1
   v_ssblk=ssnblks(:);
   if mv_trace
     disp('  State Space block numbers (ssnblks)')
     disp(v_ssblk')
   end
else
   v_ssblk=[];
   if mv_trace
     disp('  No State Space blocks (ssnblks does not exist)');
   end
end

if exist('tfnblks')==1
   i_mvtemp=size(tfnblks);
   if i_mvtemp(1)~=3
      disp('MVBLKB  Error tfnblks must have 3 rows')
      return;
   else
      v_tfblk=tfnblks(1,:)';
      sz_tfblk=tfnblks(2:3,:);
      if mv_trace
   disp(['  Non-common denominator MIMO tranfer ',...
        'function block numbers (tfnblks)'])
   disp(v_tfblk')
   end % if mv_trace

   end % else if i_mvtemp
else
   v_tfblk=[];
   sz_tfblk=[0;0];
   if mv_trace
     disp(['  No non-common denom. MIMO tranfer function blocks',...
          ' (tfnblks does not exist)']);
   end
end

% Max blocks
v_mvtemp=[v_nblk; v_mvblk; v_ssblk; v_tfblk];
max_mvtemp=max(v_mvtemp);

% Check for repeated or missing block numbers
if mv_trace
   disp('Checking block numbers.')
end
err_flg=0;
for i_mvtemp=1:max_mvtemp
  if length(find(v_mvtemp==i_mvtemp))~=1  % error
     err_flg=1;
     if length(find(v_mvtemp==i_mvtemp))==0  % block missing
        disp(['MVBLKB  Error Block number ',int2str(i_mvtemp),' is missing'])
     else
        disp(['MVBLKB  Error Block number ',int2str(i_mvtemp),' is repeated'])
     end
  end     % if length
end   % for i_mvtemp

if err_flg
  return
end

% Loop through the blocks
for i_mvtemp=1:max_mvtemp
  ii_mvtemp=int2str(i_mvtemp);
  if length(find(v_nblk==i_mvtemp))==1
  if mv_trace == 1
     disp(['Building SISO transfer function block ',ii_mvtemp])
  end
     eval(['[a_mvtemp,b_mvtemp,c_mvtemp,d_mvtemp]=mvtf2ss(n',...
             ii_mvtemp,',d',ii_mvtemp,');']);
  elseif length(find(v_mvblk==i_mvtemp))==1
     if mv_trace == 1
        disp(['Building MIMO transfer function block ',ii_mvtemp])
     end
     eval(['[a_mvtemp,b_mvtemp,c_mvtemp,d_mvtemp]=mvtf2ss(num',...
            ii_mvtemp,',comden',ii_mvtemp,');']);
  elseif length(find(v_ssblk==i_mvtemp))==1
     if mv_trace == 1
        disp(['Building State Space block ',ii_mvtemp])
     end
     eval(['a_mvtemp=a',ii_mvtemp,';']);
     eval(['b_mvtemp=b',ii_mvtemp,';']);
     eval(['c_mvtemp=c',ii_mvtemp,';']);
     eval(['d_mvtemp=d',ii_mvtemp,';']);

  elseif length(find(v_tfblk==i_mvtemp))==1
     if mv_trace == 1
        disp(['Building MIMO transfer function block ',ii_mvtemp])
     end
    blk_str = int2str(i_mvtemp);
    ii_mvtemp=find(v_tfblk==i_mvtemp);
for jj_num = 1:sz_tfblk(1,ii_mvtemp)  % inputs
    jj_str = int2str(jj_num);
    a_par=0;
    b_par=0;
    c_par=zeros(sz_tfblk(2,ii_mvtemp),1);
    d_par=zeros(sz_tfblk(2,ii_mvtemp),1);
    for ii_num = 1:sz_tfblk(2,ii_mvtemp) % outputs
        ii_str = int2str(ii_num);
        nij_str=['n',blk_str,ii_str,jj_str];
        dij_str=['d',blk_str,ii_str,jj_str];
        if exist(nij_str)==1
    if mv_trace
       disp(['                Converting SISO element ',ii_str,jj_str])
    end
        eval(['[a_blk,b_blk,c_blk,d_blk]=mvtf2ss(',nij_str,',',dij_str,');']);
           c_tmp=zeros(sz_tfblk(2,ii_mvtemp),length(c_blk));
           c_tmp(ii_num,:)=c_blk;
           d_tmp=zeros(sz_tfblk(2,ii_mvtemp),1);
           d_tmp(ii_num)=d_blk;
           [a_par,b_par,c_par,d_par]=mvpar(a_par,b_par,c_par,d_par,...
                                        a_blk,b_blk,c_tmp,d_tmp);
        end  % if exists
    end  % for outputs
    if jj_num==1
       a_mvtemp=a_par;
       b_mvtemp=b_par;
       c_mvtemp=c_par;
       d_mvtemp=d_par;
    else
       [a_mvtemp,b_mvtemp,c_mvtemp,d_mvtemp]...
         = mvsum(a_mvtemp,b_mvtemp,c_mvtemp,d_mvtemp,a_par,b_par,c_par,d_par);
    end  % if

end  % for  inputs

  else     % should not get here
     error(['Cannot find block ',ii_mvtemp]);
  end

  [ma_mvtemp,na_mvtemp]=size(a_mvtemp);
  [mb_mvtemp,nb_mvtemp]=size(b_mvtemp);
  [mc_mvtemp,nc_mvtemp]=size(c_mvtemp);
  if i_mvtemp==1
     sz=[ma_mvtemp;nb_mvtemp;mc_mvtemp];
     a=a_mvtemp;
     b=b_mvtemp;
     c=c_mvtemp;
     d=d_mvtemp;
  else
     sz=[sz,[ma_mvtemp;nb_mvtemp;mc_mvtemp]];
     [a,b,c,d]=append(a,b,c,d,a_mvtemp,b_mvtemp,c_mvtemp,d_mvtemp);
  end  % if i_mvtemp

if mv_trace == 1
   disp(['       ',int2str(nb_mvtemp),' inputs, ',...
			int2str(mc_mvtemp),' outputs'])
end % if mv_trace

end   %  for i_mvtemp

clear err_flg
clear nij_str
clear dij_str
clear a_mvtemp
clear b_mvtemp
clear c_mvtemp
clear d_mvtemp
clear i_mvtemp
clear a_par
clear b_par
clear c_par
clear d_par
clear a_blk
clear b_blk
clear c_blk
clear d_blk
clear c_tmp
clear d_tmp
clear ii_mvtemp
clear ii_num
clear jj_num
clear blk_str
clear max_mvtemp
clear v_mvtemp
clear v_nblk
clear v_mvblk
clear v_ssblk
clear v_tfblk
clear sz_tfblk
clear ma_mvtemp
clear na_mvtemp
clear mb_mvtemp
clear nb_mvtemp
clear mc_mvtemp
clear nc_mvtemp
clear mv_trace
clear ii_str
clear jj_str