line source
+ − function ltpdasim(block)
+ −
+ − % This is the automatic function wrapper
+ − % ========================================================================
+ − % ==================== level-2 M file S-function =========================
+ − % ========================================================================
+ − % This wrapper is the automatic function, called by every function block
+ − % in Simulink, able to execute m-file functions retrieving from Simulink:
+ − % (1) the pointer to the object(s) to be analyzed, coming in as input of
+ − % the corresponding block (ie, the DATA),
+ − % (2) the name of the function to be applied on those data, from the tag
+ − % of the currently executed block (ie, the true FUNCTION),
+ − % (3) the parameters for that particular block, retrieved from the global
+ − % shared workspace by the handle of the block (ie, the PARAMETERS).
+ − %
+ − % The output is then generated as:
+ − % OUTPUT = FUNCTION(DATA,PARAMETERS)
+ − %
+ − % This output in the end is saved into the global array containing all
+ − % the AOs (ie, all the DATA go together with other data): thus this output
+ − % will be freely accessible by all the other functions.
+ − %
+ − % The only real output to Simulink will be just the ordinal number of the
+ − % so-generated AO into the global array of AOs.
+ − %
+ − % $Id: ltpdasim.m,v 1.37 2008/12/01 20:03:51 nicola Exp $
+ −
+ −
+ − setup(block);
+ −
+ −
+ − %% Setup
+ −
+ − function setup(block)
+ −
+ − % Register dialog parameter: none, because they're retrieved directly
+ − % from the memory. This will prevent the user to modify the parameters
+ − % outside the proper parameters panel:
+ − block.NumDialogPrms = 0;
+ −
+ − % Register number of input and output ports
+ − block.NumInputPorts = 1;
+ − block.NumOutputPorts = 1;
+ −
+ − % Setup functional port properties to dynamically inherited.
+ − block.SetPreCompInpPortInfoToDynamic;
+ −
+ − block.InputPort(1).DirectFeedthrough = true;
+ − block.InputPort(1).DatatypeID = 0;
+ − block.InputPort(1).Complexity = 0;
+ − block.OutputPort(1).DatatypeID = 0;
+ − block.OutputPort(1).Complexity = 0;
+ − block.SampleTimes = [0 0];
+ − block.SetAccelRunOnTLC(false);
+ −
+ − block.OutputPort(1).Dimensions = 1;
+ −
+ − % Register methods
+ − block.RegBlockMethod('SetInputPortSamplingMode',@SetInpPortFrameData);
+ − block.RegBlockMethod('SetInputPortDimensions', @SetInpPortDims);
+ − block.RegBlockMethod('Outputs', @Outputs);
+ −
+ − function SetInpPortFrameData(block, idx, fd) %#ok<INUSL>
+ − block.InputPort(1).SamplingMode = fd;
+ − block.OutputPort(1).SamplingMode = fd;
+ −
+ − function SetInpPortDims(block, idx, di)
+ − block.InputPort(idx).Dimensions = di;
+ −
+ −
+ − %% Outputs
+ − function Outputs(block)
+ − global LTPDAinvar gl loop execModels %#ok<NUSED>
+ −
+ − % disp(['The name of the currently executed block is ',get_param(get_param(gcbh,'Parent'),'Name')])
+ − % disp(['The current size of LTPDAinvar is ',num2str(size(LTPDAinvar,1))])
+ −
+ − currparent = get_param(gcbh,'Parent');
+ − subsyshandle = get_param(currparent, 'handle');
+ −
+ − % Check if it's a partial execution:
+ − if ismember('executionList',evalin('base','who'))
+ − executionList = evalin('base','executionList');
+ − blockIndex = -1;
+ − for i=1:size(executionList,1), if executionList(i)==gcbh, blockIndex = i; break; end; end
+ − if blockIndex == -1 % this block is not included in the list of those to be executed.
+ − disp([' . Partial execution: block ',get_param(subsyshandle,'Name'),' will be skipped.'])
+ − block.OutputPort(1).Data = -1;
+ − return
+ − else
+ − % Check if the block must receive data from Simulink or retrieve them from a previous calculation:
+ − if block.InputPort(1).Data(1)==-1
+ − annotation = find_system(bdroot,'FindAll','on','Type','Annotation','Tag','ltpda model');
+ − execHistory = get_param(annotation,'UserData');
+ − blockIndex = -1;
+ − for i=1:size(execHistory,1), if execHistory{i,2}==subsyshandle, blockIndex = i; end; end
+ − if blockIndex == -1 % something's wrong: the selected block is not included in the previous execution history
+ − warning(['*** Partial execution: impossible to retrieve inputs. The block ',get_param(subsyshandle,'Name'),' seems to have never been executed.'])
+ − block.OutputPort(1).Data = -1;
+ − return
+ − end
+ − j=3;
+ − while ~isempty(execHistory{blockIndex,j})
+ − block.InputPort(1).Data(j-2) = execHistory{blockIndex,j};
+ − j = j+1;
+ − end
+ − disp([' . Partial execution: block ',get_param(subsyshandle,'Name'),' will now be executed with data retrieved from previous calculation.'])
+ − else
+ − disp([' . Partial execution: block ',get_param(subsyshandle,'Name'),' will now be executed.'])
+ − end
+ − end
+ − end
+ −
+ − % Check if the user wants to stop the execution:
+ − lastChar = get(findobj('Name','LTPDA Progress Bar'),'CurrentCharacter');
+ − if ~isempty(lastChar) && strcmp(lastChar,'x')
+ − set_param(bdroot, 'SimulationCommand', 'stop')
+ − return
+ − end
+ −
+ − % Update the progress bar window:
+ − progressBar = findobj('Tag','progressaxes');
+ − if ~isempty(progressBar)
+ − blocksTotal = get(findobj('Tag','blockstotal'),'UserData');
+ − blocksDone = get(findobj('Tag','done'),'UserData');
+ − blocksToGo = get(findobj('Tag','togo'),'UserData');
+ − set(findobj('Tag','done'),'UserData',blocksDone+1);
+ − set(findobj('Tag','togo'),'UserData',blocksToGo-1);
+ − set(findobj('Tag','done'),'String',['Done: ',num2str(blocksDone+1)]);
+ − set(findobj('Tag','togo'),'String',['To go: ',num2str(blocksToGo-1)]);
+ − currblockname = get_param(get_param(gcbh,'Parent'),'Name');
+ − for i=1:numel(currblockname), if double(currblockname(i))==10, currblockname(i)=' '; end; end
+ − set(findobj('Tag','currentexec'),'String',['Current block: ',currblockname]);
+ − progressSize = get(progressBar,'UserData');
+ − progressPosition = get(progressBar,'Position');
+ − progressPosition(3) = 1+(progressSize(3)/blocksTotal)*(blocksDone+1);
+ − set(progressBar,'Position',progressPosition)
+ − progressBarLoop = findobj('Tag','progressaxes2');
+ − if ~isempty(progressBarLoop)
+ − set(findobj('Tag','done'),'String',['Blocks done: ',num2str(blocksDone+1)]);
+ − loopStatus = getappdata(0,'loopStatus');
+ − progressSize = get(progressBarLoop,'UserData');
+ − progressLoopPosition = get(progressBarLoop,'Position');
+ − progressLoopPosition(3) = 1+(progressSize(3)/loopStatus(1))*loopStatus(2);
+ − set(progressBarLoop,'Position',progressLoopPosition)
+ − end
+ − drawnow
+ − end
+ −
+ − % Retrieve the function name from the block tag:
+ − blocktag = get_param(gcb, 'tag');
+ − if strcmp(blocktag,'generic')
+ − paramcommand = get_param(get_param(get_param(gcbh,'Parent'), 'handle'),'Description');
+ − eval(paramcommand)
+ − blocktag = functionName;
+ − end
+ −
+ − % ========================================================================
+ − %% For arithmetic blocks
+ − % ========================================================================
+ −
+ − if strcmp(blocktag,'arithmetic')
+ − eq = get_param(currparent,'MaskDescription');
+ − if strcmp(eq,'Arithmetic block: the user can type in the desidered equation.')
+ − disp(sprintf('Error: in the ''%s'' arithmetic block no equation has been typed in.',get_param(currparent,'Name')))
+ − close(findobj('Name','LTPDA Progress Bar'))
+ − error(['Error: in the ',get_param(currparent,'Name'),' arithmetic block no equation has been typed in.'])
+ − end
+ − equation = eq;
+ − equation(strfind(equation,char(10))) = [];
+ −
+ − paramcommand = get_param(subsyshandle,'Description');
+ − if isempty(paramcommand), paramcommand = 'params=plist(''alpha'',''-->'',''beta'',''-->'');'; end
+ − eval(paramcommand)
+ −
+ − for i=1:nparams(params)
+ − inputBlock = find_system(currparent,'SearchDepth',1,'LookUnderMasks','all','Name',lower(params.params(i).key));
+ − if numel(inputBlock)>1, inputBlock(1)=[]; end % this can happen only when the currparent has the same name: then, ignore the 1st, ie. the currparent itself
+ − inputNumb = get_param(inputBlock{1},'Tag');
+ − equation = strrep(equation,lower(params.params(i).key),['LTPDAinvar{block.InputPort(1).Data(',inputNumb,'),1}']);
+ − end
+ −
+ − try
+ − outdata = eval(equation);
+ −
+ − % Setting the output signal name:
+ − ifsetName = get_param(currparent,'UserData');
+ − if ~isempty(ifsetName) && isa(ifsetName,'char')
+ − % ifsetName = ifsetName;
+ − else
+ − ifsetName = get_param(currparent,'Name');
+ − end
+ − if numel(outdata)==1
+ − outdata = setName(outdata,ifsetName);
+ − else
+ − for i=1:size(outdata,1)
+ − for j=1:size(outdata,2)
+ − outdata(i,j) = setName(outdata(i,j),[ifsetName,'_',num2str(i),'-',num2str(j)]);
+ − end
+ − end
+ − end
+ −
+ − x = size(LTPDAinvar,1);
+ − blockName = currparent;
+ − for i=1:numel(blockName), if double(blockName(i))==10, blockName(i)=' '; end; end
+ − LTPDAinvar = [LTPDAinvar;{outdata,0,blockName}];
+ − block.OutputPort(1).Data = x+1;
+ −
+ − probe = get_param(currparent,'MaskHelp');
+ − if ~isempty(probe) && isa(probe,'char') && strcmp(probe,'probe')
+ − LTPDAinvar{size(LTPDAinvar,1),2} = 2;
+ − end
+ −
+ − return
+ −
+ − catch err
+ − disp(sprintf('Something''s wrong in the calculation of the results of the ''%s'' arithmetic block.',get_param(currparent,'Name')))
+ − disp('The inputs were:')
+ − for i=1:nparams(params)
+ − disp(['Input ',num2str(i),':'])
+ − LTPDAinvar{block.InputPort(1).Data(i),1} %#ok<NOPRT>
+ − end
+ − disp('The equation was:')
+ − disp(eq)
+ − close(findobj('Name','LTPDA Progress Bar'))
+ −
+ − rethrow(err)
+ −
+ − end
+ − end % for the arithmetic block
+ −
+ − % ========================================================================
+ − %% =================== RETRIEVE THE PARAMETERS LIST ======================
+ − % ========================================================================
+ −
+ − % The command line to produce the proper parameters list for the block
+ − % currently executed is retrieved from the description of this parent subsystem
+ − paramcommand = get_param(subsyshandle,'Description');
+ − loopExecution = 0;
+ −
+ − if ~isempty(paramcommand)
+ − eval(paramcommand);
+ −
+ − % Verify if a global variable or nested loop variable has been used:
+ − for i=1:nparams(params)
+ − currVal = params.params(i).val;
+ − if ischar(currVal) && numel(currVal)>5 && strcmp(currVal(1:5),'loop.')
+ − loopExecution = 1;
+ − try %#ok<ALIGN>
+ − setVal(params.params(i),eval(params.params(i).val));
+ − catch, end
+ − end
+ − if ischar(currVal) && numel(currVal)>3 && strcmp(currVal(1:3),'gl.')
+ − try %#ok<ALIGN>
+ − setVal(params.params(i),eval(params.params(i).val));
+ − catch, end
+ − end
+ − end
+ −
+ − if ~exist('paramEnabled','var'), paramEnabled = ones(1,nparams(params)); end
+ − currparam = plist();
+ − for jj=1:nparams(params)
+ − if paramEnabled(jj)==1
+ − if numel(params.params(jj).key)>6 && strcmpi(params.params(jj).key(1:7),'addPar_'), params.params(jj).setKey(params.params(jj).key(8:end)); end
+ − currparam = append(currparam,params.params(jj));
+ − end
+ − end
+ − else
+ − currparam = plist();
+ − end
+ −
+ − % Retrieve parameters from Simulink:
+ − paramFromSimulink = 0;
+ − for i=1:nparams(currparam)
+ − paramKey2 = currparam.params(i).key;
+ − if numel(paramKey2)>7 && strcmpi(paramKey2(1:7),'addPar_'), paramKey = paramKey2(8:end); else paramKey = paramKey2; end
+ − paramVal = currparam.params(i).val;
+ − if (isa(paramVal,'char') && strcmp(paramVal,'-->')) || (isa(paramVal,'cell') && numel(paramVal)==1 && isa(paramVal{1},'char') && strcmp(paramVal{1},'-->'))
+ − paramFromSimulink = paramFromSimulink + 1;
+ − mux = find_system(currparent,'SearchDepth',1,'LookUnderMasks','all','BlockType','Mux');
+ − muxWidths = get_param(mux{1},'CompiledPortWidths');
+ − muxWidths = muxWidths.Inport;
+ − inputBlock = find_system(currparent,'SearchDepth',1,'LookUnderMasks','all','Name',lower(paramKey));
+ − if numel(inputBlock)>1, inputBlock(1)=[]; end % this can happen only when the currparent has the same name: then, ignore the 1st, ie. the currparent itself
+ − inputNumb = str2double(get_param(inputBlock{1},'Tag'));
+ − x = 0;
+ − for j=1:inputNumb-1
+ − x=x+muxWidths(j);
+ − end
+ − paramVal = [LTPDAinvar{block.InputPort(1).Data(x+1)}];
+ − if muxWidths(inputNumb)>1
+ − for j=x+2:x+muxWidths(inputNumb)
+ − paramVal = [paramVal,LTPDAinvar{block.InputPort(1).Data(j)}];
+ − end
+ − end
+ − currparam = pset(currparam,paramKey2,paramVal);
+ − end
+ − end
+ −
+ − % ========================================================================
+ − %% ======================== CALCULATE THE RESULTS =========================
+ − % ========================================================================
+ −
+ − y = length(block.InputPort(1).Data) - paramFromSimulink;
+ −
+ − % Check to verify the type of function:
+ − specFunc = {'display'};
+ − [meth,clas] = strtok(get(get_param(currparent,'Handle'),'Tag'));
+ − category = '';
+ − if strcmp(meth,'method')
+ − clas = strtrim(clas);
+ − infoObj = eval([clas,'.getInfo(''',blocktag,''')']);
+ − category = infoObj.mcategory;
+ − end
+ −
+ − if ismember(blocktag,specFunc)
+ − % Input, but no parameters and no output
+ − type = 4;
+ − % ======================================
+ − elseif strcmp(category,'Output')
+ − % Input and parameters, but no output
+ − type = 3;
+ − % ===================================
+ − elseif ~isempty(utils.prog.find_in_models(currparent,'SearchDepth',1,'LookUnderMasks','all','BlockType','Ground')) || block.InputPort(1).Data(1)==0
+ − % No input, but parameters and output
+ − type = 2;
+ − % ===================================
+ − elseif nparams(currparam)==0
+ − % Input and output, but no parameters
+ − type = 1;
+ − % ============================
+ − else
+ − % Input, parameters and output
+ − type = 0;
+ − % ============================
+ − end
+ −
+ −
+ − switch type
+ − % ====================================================================
+ − case 4 % Input, but no parameters and no output
+ − command = 'feval(blocktag,';
+ − for i=1:y
+ − dVal = block.InputPort(1).Data(i);
+ − if dVal>0, command = [command sprintf('LTPDAinvar{%d},', dVal)]; end
+ − end
+ − command = [command(1:end-1) ');'];
+ − try
+ − eval(command)
+ − catch err
+ − disp('4')
+ − disp(sprintf('Something''s wrong in the calculation of the results of the %s function.',blocktag))
+ − disp(sprintf('The name of the currently executed block is %s.',get_param(currparent,'Name')))
+ − disp(sprintf('The (first) input data ordinal number, in the list of objects, was %d.',block.InputPort(1).Data(1)))
+ − close(findobj('Name','LTPDA Progress Bar'))
+ − rethrow(err)
+ − end
+ − block.OutputPort(1).Data = 1; % this will be ignored: no output expected.
+ − return;
+ −
+ − % ====================================================================
+ − case 3 % Input and parameters, but no output
+ − try
+ − command = 'feval(blocktag,';
+ − for i=1:y
+ − dVal = block.InputPort(1).Data(i);
+ − if dVal>0, command = [command sprintf('LTPDAinvar{%d},', dVal)]; end
+ − end
+ − command = [command 'currparam);'];
+ − if strcmpi(blocktag,'plot'), figure; end;
+ − eval(command);
+ − catch err
+ − disp('3')
+ − disp(sprintf('Something''s wrong in the calculation of the results of the %s function.',blocktag))
+ − disp(sprintf('The name of the currently executed block is %s.',get_param(currparent,'Name')))
+ − disp(sprintf('The (first) input data ordinal number, in the list of objects, was %d.',block.InputPort(1).Data(1)))
+ − disp('The plist passed was:')
+ − currparam %#ok<NOPRT>
+ − close(findobj('Name','LTPDA Progress Bar'))
+ − rethrow(err)
+ − end
+ − block.OutputPort(1).Data = 1; % this will be ignored: no output expected.
+ − return;
+ −
+ − % ====================================================================
+ − case 2 % No input, but parameters and output
+ − try
+ − outdata = feval(blocktag,currparam);
+ − catch err
+ − disp('2')
+ − disp(sprintf('Something''s wrong in the calculation of the results of the %s function.',blocktag))
+ − disp(sprintf('The name of the currently executed block is %s.',get_param(currparent,'Name')))
+ − disp('The plist passed was:')
+ − currparam %#ok<NOPRT>
+ − close(findobj('Name','LTPDA Progress Bar'))
+ − rethrow(err)
+ − end
+ −
+ − % ====================================================================
+ − case 1 % Input and output, but no parameters
+ − try
+ − command = 'outdata = feval(blocktag,';
+ − for i=1:y
+ − dVal = block.InputPort(1).Data(i);
+ − if dVal>0, command = [command sprintf('LTPDAinvar{%d},', dVal)]; end
+ − end
+ − command = [command(1:end-1) ');'];
+ − eval(command);
+ − catch err
+ − disp('1')
+ − disp(sprintf('Something''s wrong in the calculation of the results of the %s function.',blocktag))
+ − disp(sprintf('The name of the currently executed block is %s.',get_param(currparent,'Name')))
+ − disp(sprintf('The (first) input data ordinal number, in the list of objects, was %d.',block.InputPort(1).Data(1)))
+ − disp('The plist passed was:')
+ − currparam %#ok<NOPRT>
+ − close(findobj('Name','LTPDA Progress Bar'))
+ − rethrow(err)
+ − end
+ − % ====================================================================
+ − case 0 % Input, parameters and output
+ − try
+ − command = 'outdata = feval(blocktag,';
+ − for i=1:y
+ − dVal = block.InputPort(1).Data(i);
+ − if dVal>0, command = [command sprintf('LTPDAinvar{%d},', dVal)]; end
+ − end
+ − command = [command 'currparam);'];
+ − eval(command);
+ − catch err
+ − disp('1')
+ − disp(sprintf('Something''s wrong in the calculation of the results of the %s function.',blocktag))
+ − disp(sprintf('The name of the currently executed block is %s.',get_param(currparent,'Name')))
+ − disp(sprintf('The (first) input data ordinal number, in the list of objects, was %d.',block.InputPort(1).Data(1)))
+ − disp('The plist passed was:')
+ − currparam %#ok<NOPRT>
+ − close(findobj('Name','LTPDA Progress Bar'))
+ − rethrow(err)
+ − end
+ −
+ − end
+ −
+ − %==========================================================================
+ − %% Cycle to remove objects from memory as soon as they're no longer necessary:
+ − %==========================================================================
+ −
+ − if ~getappdata(0,'maintainresults');
+ − portConnectivity = get(subsyshandle,'PortConnectivity');
+ − for i = 1:numel(portConnectivity)
+ − notUsedAnymore = 1;
+ − if isempty(portConnectivity(i).DstBlock)
+ − parentBlock = portConnectivity(i).SrcBlock;
+ − childrenBlocks = utils.prog.findchildren(parentBlock);
+ − for j = 1:numel(childrenBlocks)
+ − if isempty(get_param(childrenBlocks(j),'MaskVariables')), notUsedAnymore = 0; end
+ − end
+ − % disp(sprintf('*** (Currently executing block %s)',get_param(currparent,'Name')))
+ − if notUsedAnymore && LTPDAinvar{block.InputPort(1).Data(i),2}==0
+ − % disp(['*** Removed object n°.',num2str(block.InputPort(1).Data(i)),', which was a ',class(LTPDAinvar{block.InputPort(1).Data(i),1}),'.'])
+ − disp(sprintf('*** (Currently executing block %s)',get_param(currparent,'Name')))
+ − LTPDAinvar(block.InputPort(1).Data(i),:) = [];
+ −
+ − % Update the execution history:
+ − ltpda_annotation = find_system(bdroot,'FindAll','on','Type','Annotation','Tag','ltpda model');
+ − execHistory = get_param(ltpda_annotation,'UserData');
+ − for xx=1:size(execHistory,1)
+ − for yy=3:size(execHistory,2),
+ − if execHistory{xx,yy} == block.InputPort(1).Data(i), execHistory{xx,yy} = -1; end
+ − if execHistory{xx,yy} > block.InputPort(1).Data(i), execHistory{xx,yy} = execHistory{xx,yy}-1; end
+ − end
+ − if execHistory{xx,1} == block.InputPort(1).Data(i), execHistory{xx,1} = -1; end
+ − if execHistory{xx,1} > block.InputPort(1).Data(i), execHistory{xx,1} = execHistory{xx,1}-1; end
+ − end
+ − set_param(ltpda_annotation,'UserData',execHistory);
+ −
+ − disp('*** LTPDA object cleared from memory, being now unused')
+ − end
+ − end
+ − end
+ − end
+ − % ========================================================================
+ − %% =============================== OUTPUTS ================================
+ − % ========================================================================
+ −
+ − % Set this block status to 'executed':
+ − set(subsyshandle,'MaskVariables','1');
+ − set(gcbh,'MaskVariables','1');
+ −
+ − signalName = get_param(currparent,'Name');
+ − ifsetName = get_param(currparent,'UserData');
+ − if ~isempty(ifsetName) && isa(ifsetName,'double') && ifsetName==1
+ − if numel(outdata)==1
+ − outdata = setName(outdata,signalName);
+ − else
+ − for i=1:size(outdata,1)
+ − for j=1:size(outdata,2)
+ − outdata(i,j) = set(outdata(i,j),'name',[signalName,'_',num2str(i),'-',num2str(j)]);
+ − end
+ − end
+ − end
+ − end
+ −
+ − try
+ − % To prevent the result calculated here from being canceled at the
+ − % end of the calculation:
+ − probe = get_param(currparent,'MaskHelp');
+ − if ~isempty(probe) && isa(probe,'char') && strcmp(probe,'probe'), keepThis = 1;
+ − else keepThis = 0;
+ − end
+ −
+ − % Appending the results:
+ − ltpda_annotation = find_system(bdroot,'FindAll','on','Type','Annotation','Tag','ltpda model');
+ − execHistory = get_param(ltpda_annotation,'UserData');
+ − % If there's a previous execution history, check if the current block belongs to it:
+ − if ~isempty(execHistory)
+ − member = 0;
+ − for i=1:size(execHistory,1)
+ − if execHistory{i,2}==subsyshandle, member = 1; index = i; break; end
+ − end
+ − end
+ − if ~isempty(execHistory) && member && ~loopExecution
+ − x = execHistory{index,1};
+ − if x==-1, x = size(LTPDAinvar,1)+1; end
+ − for i=1:numel(currparent), if double(currparent(i))==10, currparent(i)=' '; end; end
+ − LTPDAinvar(x,:) = {outdata,keepThis,currparent};
+ − block.OutputPort(1).Data = x;
+ − execHistory{index,1} = x ;
+ − execHistory{index,2} = subsyshandle ;
+ − for i=1:y , execHistory{index,2+i} = block.InputPort(1).Data(i); end
+ − else
+ − if isempty(execHistory), execHistory = {}; end
+ − x = size(LTPDAinvar,1);
+ − LTPDAinvar = [LTPDAinvar;{outdata,keepThis,currparent}];
+ − block.OutputPort(1).Data = x+1;
+ − execHistory{end+1,1} = x+1 ;
+ − execHistory{end,2} = subsyshandle ;
+ − for i=1:y , execHistory{end,2+i} = block.InputPort(1).Data(i); end
+ − end
+ −
+ − % Update the execution history:
+ − % Are stored the the output obj pointer, the handle of the current subsytem and the input obj pointers:
+ − set_param(ltpda_annotation,'UserData',execHistory);
+ −
+ −
+ − catch
+ − disp('------------------============================================------------------')
+ − disp('------------------============================================------------------')
+ − disp('------------------============================================------------------')
+ − disp(sprintf('Something''s wrong in appending to the global variable LTPDAinvar the results of the %s function.',blocktag))
+ − disp(sprintf('The name of the currently executed block is %s.',get_param(currparent,'Name')))
+ − disp('The data to be saved, calculated into this block, are:')
+ − outdata %#ok<NOPRT>
+ − disp('------------------============================================------------------')
+ − disp('------------------============================================------------------')
+ − disp('------------------============================================------------------')
+ − end
+ −
+ − %==========================================================================
+ −
+ − % The output to Simulink is just the ordinal number (ONE AND ONLY ONE
+ − % NUMBER) of the object appended to the global array LTPDAinvar.
+ −
+ − % endfunction