Generate Reusable Code from Library Subsystems Shared Across Models - MATLAB & Simulink (original) (raw)

What Is a Reusable Library Subsystem?

A reusable library subsystem is a subsystem included in a library that is configured for reuse. You must define a subsystem in a library and configure it for reuse to reuse the subsystem across models.

To reuse common functionality, you can include multiple instances of a subsystem:

• Within a single model, which is a top model or part of model reference hierarchy
• Across multiple referenced models in a model reference hierarchy
• Across multiple top models that contain Model blocks
• Across multiple top models that do not include Model blocks

The code generator uses checksums to determine reusability. There are cases when the code generator cannot reuse subsystem code.

For incremental code generation, if the reusable library subsystem changes, a rebuild of itself and its parents occurs. During the build, if a matching function is not found, a new instance of the reusable function is generated into the shared utilities folder. If a different matching function is found from previous builds, that function is used, and a new reusable function is not emitted.

For subsequent builds, unused files are not replaced or deleted from your folder. During development of a model, when many obsolete shared functions exist in the shared utilities folder, you can delete the folder and regenerate the code. If all instances of a reusable library subsystem are removed from a model reference hierarchy and you regenerate the code, the obsolete shared functions remain in the shared utilities folder until you delete them.

If a model changes such that the change might cause different generated code for the subsystem, a new reusable function is generated. For example, model configuration parameters that modify code comments might cause different generated code for the subsystem even if the reusable library subsystem did not change.

Embedded Coder® users can generate code from a library that contains subsystems are configured for reuse. For more information, see Library-Based Code Generation for Reusable Library Subsystems.

Reusable Library Subsystem Code Placement and Naming

The generated code of a reusable library subsystem is independent of the generated code of the model. Code for the reusable library subsystem is generated to the shared utility folder, slprj/_`target`_/_sharedutils, instead of the model reference hierarchy folders. The generated code for the supporting types, which are generated to the .h file, are also in the shared utilities folder. Code templates applied to the generated code of the model also apply to generated code for the reusable library subsystem.

For unique naming, reusable function names have a checksum appended to the reusable library subsystem name. For example, the code and files for a subsystem,SS1, which links to a reusable library subsystem,RLS, might be:

• Function name: RLS_mgdjlngd
• File name: RLS_mgdjlnd.c andRLS_mgdjlnd.h

To configure a reusable library subsystem, set the Subsystem parameters as listed here:

• Select Treat as an atomic unit.
• On the Code Generation tab:
  • Set Function packaging toReusable function.
  • Set the Function name options andFile name options parameters based on this table. This table summarizes how the code generator produces code and highlights the File name options in bold that enable you to generate code from reusable library subsystems. For the purpose of this table, assume that the Subsystem block is named mySubsystem, the File name value for the User specified option is myFunction, and the Subsystem methods naming rule model configuration parameter has the default value$R$N$M$F.

    Function Name Options	File Name Options	Generated Folder Location	Generated Function Name	Generated File Names
    Auto	Auto	/slprj/target/_sharedutils	mySubsystem_ checksum	mySubsystem_ checksum.c,mySubsystem_ checksum.h
    Use subsystem name	/slprj/target/_sharedutils	mySubsystem_ checksum	mySubsystem_ checksum.c,mySubsystem_ checksum.h
    Use function name	/slprj/target/_sharedutils	mySubsystem_ checksum	mySubsystem_ checksum.c,mySubsystem_ checksum.h
    User specified	model_target_rtw	model_Subsystem	myFile.h
    Use subsystem name	Auto	model_target_rtw	model_Subsystem	Generated code included in_model_.h
    Use subsystem name	/slprj/target/_sharedutils	mySubsystem_ checksum	mySubsystem_ checksum.c,mySubsystem_ checksum.h
    Use function name	/slprj/target/_sharedutils	mySubsystem_ checksum	mySubsystem_ checksum.c,mySubsystem_ checksum.h
    User specified	model_target_rtw	model_Subsystem	myFile.h
    User specified	Auto (This specification is supported for one unique instance of the subsystem in the model.)	/slprj/target/_sharedutils	myFunction	myFunction.c, myFunction.h
    Use subsystem name	model_target_rtw	myFunction	mySubsystem.c, mySubsystem.h
    Use function name (This specification is supported for one unique instance of the subsystem in the model.)	/slprj/target/_sharedutils	myFunction	myFunction.c, myFunction.h
    User specified (This specification is supported if the user-specified function name and file name are same and only for one unique instance of the subsystem in the model.)	/slprj/target/_sharedutils	myFunction	myFunction.c, myFunction.h

For more information about the Subsystem block parameters, see Subsystem.

Configure Models That Include Reusable Library Subsystems

For a model to use a reusable library subsystem, you must configure the model differently depending on whether the model is a reference model or top model. If the subsystem is in a referenced model hierarchy, set the configuration parameter, Shared code placement toAuto. Otherwise, for each model that uses the subsystem, set the model configuration parameter Shared code placement toShared location.

If a reusable library subsystem uses a shared local data store and you configure default mapping for model data elements, leave the default storage class mapping for category Shared local data stores set to .

In a model reference hierarchy, if an instance of the reusable library subsystem is in the top model, then on the Model Referencing pane of the Configuration Parameters dialog box, you must select the Pass fixed-size scalar root input by value for code generation parameter. If you do not select the parameter, a separate shared function is generated for the reusable library subsystem instance in the top model, and a reusable function is generated for instances in the referenced models.

If a reusable library subsystem is connected to the root Outport, reuse does not happen with identical subsystems that are not connected to the root Outport. However, you can set Pass reusable subsystem outputs as toIndividual arguments on theOptimizations pane to make sure that reuse occurs between these subsystems. This parameter requires an Embedded Coder license.

For more information on creating a library, see Libraries and Blocksets. For an example of creating a reusable library subsystem, see Generate Reusable Code for Subsystems Shared Across Models.

Generate Reusable Code for Subsystems Shared Across Models

This example shows how to configure a reusable library subsystem and generate a reusable function for a subsystem shared across referenced models. The result is reusable code for the subsystem, which is generated to the shared utility folder (slprj/_`target`_/_sharedutils).

• Create a reusable library subsystem.
• Create the example model.
• Set configuration parameters of the top model.
• Create and propagate a configuration reference.
• Generate and view the code.

Create a reusable library subsystem.

1. In the Simulink Editor, on the tab, select . Select from the Simulink Start Page window. OpenGeneratedCodeFunctionReuse.
   openExample('GeneratedCodeFunctionReuse')
2. Copy and paste subsystem SS1 into the Library Editor. This action loads the variables for SS1 into the base workspace. Rename the subsystem block to RLS.
   
3. Click the Subsystem block and press Ctrl+U to view the contents of subsystem RLS.
   
4. To configure the subsystem, in the Library editor, right-clickRLS. In the context menu, select . In the Subsystem Parameters dialog box, choose the following options:
   • Select Treat as an atomic unit.
   • On the Code Generation tab:
     * Set Function packaging toReusable function.
     * Set Function name options toUser specified and verify that the Function name is set tomyfun.
     * Set File name options toAuto.
5. Click Apply and OK.
6. Save the reusable library as ssreuselib, which creates a file, ssreuselib.slx.

Create the example model.

1. Create a model which includes one instance of RLS fromssreuselib. Name this subsystemSS1. Add another subsystem and name itSS2. Name the model ex_model1.
   
2. Create another model which includes one instance of RLS from ssreuselib. Name this subsystemSS1. Add another subsystem and name itSS3. Name the model ex_model2.
   
3. Create a top model with two model blocks that referenceex_model1 and ex_model2. Save the top model as ex_mdlref_ssreuse.
   

Set configuration parameters of the top model.

1. With model ex_mdlref_ssreuse open in the Simulink® Editor, on the tab, click to open the Configuration Parameters dialog box.
2. On the Solver pane, specify theType asFixed-step.
3. On the Model Referencing pane, click the ellipsis to view the advanced parameters. Then, select Pass fixed-size scalar root inputs by value for code generation.
4. On the Code Generation > Report pane, selectCreate code generation report and Open report automatically.
5. On the Code Generation > Interface pane, set theShared code placement to Shared location.
6. On the Code Generation > Identifiers pane, set theMaximum identifier length to256. This step is optional.
7. Click Apply and OK.

Create and propagate a configuration reference.

1. In the Simulink Editor, on the tab, click to open the Model Explorer. In the left navigation column of the Model Explorer, expand theex_mdlref_ssreuse node.
2. Select the Configurations node below theex_mdlref_ssreuse node. In theContents pane, right-clickConfiguration and select Convert to Configuration Reference.
3. In the Convert Active Configuration to Reference dialog box, clickOK. This action converts the model configuration set to a configuration reference, Simulink.ConfigSetRef, and creates the configuration reference object,configSetObj, in the base workspace.
4. In the left navigation column, right-click Reference (Active) and select Propagate to Referenced Models.
5. In the Configuration Reference Propagation to Referenced Models dialog box, select the referenced models in the list. ClickPropagate.

Now, the top model and referenced models use the same configuration reference,Reference (Active), which points to a model configuration reference object, configSetObj, in the base workspace. When you save your model, you also need to export the configSetObj to a MAT-file.

Generate and view the code.

1. To generate code, in the Simulink Editor, press Ctrl+B. After the code is generated, the code generation report opens.
2. To view the code generation report for a referenced model, in the left navigation pane, in the Referenced Models section, select ex_model1. The code generation report displays the generated files for ex_model1.
3. In the left navigation pane, expand the Shared files. The code generator uses the reusable library subsystem name. The code for subsystem SS1 is in myfun.c andmyfun.h.
   
4. Click Back and navigate to theex_model2 code generation report.ex_model2 uses the same source code,myfun.c and myfun.h, as the code for ex_model1. Your subsystem function and file names will be different.

See Also

Topics

• Libraries and Blocksets
• Generate Reentrant Code from Subsystems
• Generate Subsystem Code as Separate Function and Files
• Determine Why Subsystem Code Is Not Reused