create simulink report generator reports -凯发k8网页登录

import the api functions.

to eliminate the need to use fully qualified names of report, finder, and dom api functions, use these statements. for example, instead of using slreportgen.finder.blockfinder, you can use blockfinder.

import slreportgen.report.*
import slreportgen.finder.*
import mlreportgen.report.*

load the slrgex_sf_car model.

model = load_system('slrgex_sf_car');

create a report object.

use a simulink report constructor (slreportgen.report.report) to create a report object to hold the contents of the report. you must fully qualify the name of the constructor to distinguish it from the matlab report constructor (mlreportgen.report.report). set the name of the report to sdd_ followed by the value of the name property of the model.

rpt = slreportgen.report.report(['sdd_'...
    get_param('slrgex_sf_car','name')],'pdf');

to customize properties that apply to the whole report, see .

add a title page.

use a title page reporter constructor (mlreportgen.report.titlepage) to create a title page reporter. this reporter generates a title page based on its properties. set the title, subtitle, and author properties to character arrays that specify the report title, subtitle, and author, respectively.

use a diagram reporter constructor (slreportgen.report.diagram) to create a diagram reporter for this model. this reporter generates an image of the block diagram of the model. to include this image on the report title page, assign the diagram reporter to the image property of the title page reporter. then, add the title page to the report.

tp = titlepage;
tp.title = upper(get_param(model,'name'));
tp.subtitle = 'system design description';
tp.author = 'mathworks';
tp.image = diagram(model);
append(rpt,tp);

to customize additional title page properties, see .

add a table of contents.

use a table of contents (toc) reporter constructor to create a toc reporter. this reporter generates a toc for the report. add the toc reporter to the report.

toc = tableofcontents;
append(rpt,toc);

to customize the table of contents, see .

add a chapter for the root system.

use a chapter constructor (mlreportgen.report.chapter) to create a chapter reporter. this reporter generates a chapter based on its title and content properties. the reporter automatically numbers the chapter title. the chapter reporter also generates the chapter page headers and footers and its page numbers.

add a model diagram reporter to the chapter. this reporter returns an image of the block diagram of the model that you add to the chapter.

ch = chapter("title","rootsystem");
append(ch,diagram(model));

for information on customizing chapters, see .

add chapter sections for each root system block.

use the block finder constructor (slreportgen.report.blockfinder) to create a block finder for the root diagram. then, use the find function of the block finder. the find function returns an array of block result objects (slreportgen.report.blockresult), each of which contains a block.

loop through the block result objects. for each result, construct a section reporter (mlreportgen.report.section). this reporter generates a numbered report section based on its title and content properties. set the section title property to the name of the block on which it reports.

add the current block result to the section reporter. adding the result sets the section reporter content property to a simulink.report.simulinkobjectproperties reporter. this simulinkobjectproperties reporter generates a table of the properties of the current block, which is then added to the section. add each subsection to the parent chapter. then add the chapter to the report.

blkfinder = blockfinder(model);
blocks = find(blkfinder);
for block = blocks
    section = section("title", ...
       strrep(block.name, newline,' '));
    append(section,block);
    append(ch,section);
end
append(rpt,ch);

for information finding blocks and how to customize sections, see and , respectively.

add a chapter for subsystems.

create a chapter for the subsystems of the model and the blocks in each subsystem.

ch = chapter("title","subsystems");

find subsystem diagrams in the model.

find all subsystem diagrams in the model. the finder returns an array of diagramresult objects, each of which contains a diagram reporter that creates a snapshot of the subsystem diagram.

sysdiagfinder = systemdiagramfinder(model);
sysdiagfinder.includeroot = false;

for more information, see and

add results to chapter sections.

using loops, create a chapter section for each subsystem. find the blocks and block elements in each subsystem. add a table of block elements to each chapter section and add each section to the chapter. then, add the chapter to the report.

while hasnext(sysdiagfinder)
    system = next(sysdiagfinder);
    section1 = section("title",system.name);
    append(section1,system);
    
    blkfinder1 = blockfinder(system);
    elems = find(blkfinder1);
    for elem = elems
       section2 = section("title",...
           strrep(elem.name,newline,' '));
       append(section2,elem);
       append(section1,section2);
    end
    append(ch,section1);
end
append(rpt,ch);
 

add a chapter for stateflow charts and objects.

find all stateflow charts in the model. create a chapter. using loops, add subsections for each chart. find all the elements in each chart and add them to the subsections. then, add the section to the chapter and the chapter to the report.

ch = chapter("title", "stateflow charts");
chdiagfinder = chartdiagramfinder(model);
while hasnext(chdiagfinder) 
   chart = next(chdiagfinder); 
   section = section("title",chart.name);
   append(section,chart);
   objfinder = stateflowdiagramelementfinder(chart);
   sfobjects = find(objfinder);
   for sfobj = sfobjects
       title = sfobj.name;
       if isempty(title)
          title = sfobj.type;
       end
       objsection = section("title",title);
       append(objsection,sfobj);
       append(section,objsection);
   end
   append(ch,section);
end
append(rpt,ch);

for information on chart and diagram element finders, see and .

close the report, run the report, and close the model.

close(rpt);
rptview(rpt);
close_system(model);