Implement Component Behavior Using Simulink

System design and architecture definitions can involve a behavior definition for some components, such as the algorithm for a data processing component. Define components in System Composer™ architecture models as behaviors using Simulink^® subsystem components that are part of the parent model, or referenced behaviors by linking components to Simulink models or subsystems.

Behavior	How to Use	More Information
Simulink model reference	Implement component behaviors with a linked Simulink model to define your system behavior and easily reuse these definitions across architectural components.	Create Reusable Simulink Behavior Using Model Reference Component
Simulink subsystem reference	Implement component behaviors with a linked Simulink subsystem to define your system behavior and easily reuse these definitions across architectural components. Subsystems support root-level physical ports to use with Simscape™ physical behaviors.	Create Reusable Simulink Behavior Using Subsystem Reference Component
Simulink subsystem component	Implement component behaviors with a Simulink subsystem that is part of the parent architecture model to define your system behavior once. Subsystems support root-level physical ports to use with Simscape physical behaviors.	Create Simulink Behavior Using Subsystem Component
Stateflow^® chart component	Implement component behaviors with a Stateflow chart that is part of the parent architecture model to define your system behavior once.	Implement Component Behavior Using Stateflow Charts

Note

System Composer interfaces mirror Simulink interfaces that use buses and value types. When you plan to link Simulink behaviors to System Composer components, consider these resources:

For buses at Simulink interfaces, see Composite Interface Guidelines.
To use model interfaces with bus element ports, see Simplify Subsystem and Model Interfaces with Bus Element Ports.
For value types at Simulink interfaces, see Specify Common Set of Signal Properties as Value Type.

You can simulate the Simulink component implementations in System Composer. Use the Simulation Data Inspector to view and compare simulation results between model designs.

Tip

To learn more about how System Composer concepts apply to systems engineering design, see System Composer Concepts.

Create Simulink Behavior with Robot Arm Model

This example uses:

Open Live Script

This example shows how to use a robot arm model to create Simulink® behavior from the Motion component.

1. Open the Robot.slx model.

model = systemcomposer.openModel('Robot');

The Robot model has an interface sensordata applied on the ports SensorData.

2. Look up the Motion component.

motionComp = lookup(model,'Path','Robot/Motion');

3. Create a Simulink behavior.

motionComp.createSimulinkBehavior('MotionSimulink');

Create Referenced Simulink Behavior Model

When a component does not require decomposition from an architecture standpoint, you can design and define the behavior of the component in Simulink. When you link to a Simulink behavior, the Component block becomes a Reference Component block.

A reference component is a component whose definition is a separate architecture model, Simulink behavior model, or Simulink subsystem behavior. A reference component represents a logical hierarchy of other compositions.

You can synchronize and reuse reference components as Reference Component blocks. There are three types of reference components:

Model references are Simulink models.
Subsystem references are Simulink subsystems.
Architecture references are System Composer architecture models or subsystems.

In this section, you will create a model reference and a subsystem reference. For more information on architecture references, see Create Architecture Model Reference.

Referenced or linked models are useful for collaborative design with version control using Simulink projects. For more information, see Organize System Composer Files in Projects.

Create Reusable Simulink Behavior Using Model Reference Component

Use Simulink model references to describe the implementation of System Composer components.

Select the Motion component. Navigate to Modeling > Create Simulink Behavior. Alternatively, right-click the Motion component and select Create Simulink Behavior.
From the Type list, select Model Reference. Provide the model name MotionSimulink. The default name is the name of the component.
A new Simulink model file with the provided name is created in the current folder. The root-level ports of the Simulink model reflect the ports of the component. The component in the architecture model is linked to the Simulink model. The icon on the component indicates that the component has a Simulink behavior.
To view the interfaces on the SensorData port converted into Simulink bus elements, double-click the port in Simulink.
To remove model behavior, right-click the linked Motion component and select Inline Model.

For more information on removing referenced behaviors, see Remove Architecture Reference.

Create Reusable Simulink Behavior Using Subsystem Reference Component

Use subsystem references to author Simulink or Simscape behaviors with physical ports, connections, and blocks. For more information, see Implement Component Behavior Using Simscape.

Select the Motion component. Navigate to Modeling > Create Simulink Behavior. Alternatively, right-click the Motion component and select Create Simulink Behavior.
From the Type list, select Subsystem Reference. Provide the model name MotionSubsystem. The default name is the name of the component.
A new Simulink subsystem file with the provided name is created in the current folder. The root-level ports of the Simulink subsystem reflect the ports of the component. The component in the architecture model is linked to the Simulink subsystem. The icon on the component indicates that the component has a Simulink subsystem behavior.

You can access and edit referenced Simulink models and subsystems by double-clicking the Reference Component in the architecture model. When you save the architecture model, all unsaved referenced Simulink behaviors are also saved, and all linked components are updated.

Create Simulink Behavior Using Subsystem Component

A subsystem component is a Simulink subsystem that is part of the parent System Composer architecture model.

Add Simulink subsystem behavior to a component to author a subsystem component in System Composer. You cannot synchronize and reuse subsystem components as Reference Component blocks because the component is part of the parent model.

Right-click the Sensor component and select Create Simulink Behavior. Alternatively, navigate to Modeling > Create Simulink Behavior.
From the Type list, select Subsystem.
The Sensor component is now a Simulink subsystem of the same name that is part of the parent System Composer architecture model.
The root-level ports of the Simulink model reflect the ports of the component. The icon on the component indicates that the component has a Simulink subsystem behavior.
You can continue to provide specific dynamics and algorithms in the Simulink subsystem behavior model. Adding root-level ports in the subsystem behavior creates additional ports on the subsystem component.
You can use subsystem components to author Simscape component behaviors with physical ports, connections, and blocks. For example, this amplifier physical system uses electrical domain blocks inside a subsystem component in a System Composer architecture model.

Convert Simulink Subsystem Component to Subsystem Reference Component

You can convert existing Simulink subsystem components that are part of the parent System Composer model to subsystem reference components. The subsystem reference components are saved separately as a reusable artifact.

Right-click the subsystem component block and select Block Parameters (Subsystem).
Click the Subsystem Reference tab.
Click Convert to open the Convert to Subsystem Reference dialog.
Choose a name for the new subsystem file. Optionally, select Transfer test harnesses to transfer test harnesses. Click Convert to complete the conversion.

To convert a subsystem component to a subsystem reference programmatically, use the createSimulinkBehavior function.

Link to Existing Simulink Behavior Model

You can link to an existing Simulink behavior model or subsystem from a System Composer component, provided that the component is not already linked to a reference architecture. Right-click the component and select Link to Model. Type in or browse for the name of a Simulink model or subsystem.

Link to model dialog with existing model name 'Motion Simulink'. Press Enter for OK.

Any subcomponents and ports in the components are deleted when the component links to a Simulink model or subsystem. A prompt displays to continue and lose subcomponents and ports.

Note

Linking a System Composer component to a Simulink model with root-level enable or trigger ports is not supported.

You can link protected Simulink models (.slxp) to create component behaviors. You can also convert an already linked Simulink behavior model to a protected model. The change is reflected when you refresh the model.

Access Model Arguments as Parameters on Reference Components

System Composer exposes instance-specific parameter values for reusable referenced models.

A parameter is an instance-specific value of a value type.

Parameters are available for inlined architectures and components. Parameters are also available for components linked to model, subsystem, or architecture references that specify model arguments. You can specify independent values for a parameter on each component.

Instance-specific parameter values are visible on the component level. View and edit these values using the Property Inspector.

Left wheel parameters with the PSI parameter set to 34.

Each parameter value can be specified independently for each component that references the model.

Right wheel parameters with the PSI parameter set to 32.

For more information, see Use Parameters to Store Instance Values with Components.

To add or modify parameters for architectures or components using the Parameter Editor, see Author Parameters in System Composer Using Parameter Editor.

Create Simulink Behavior from Template for Component

To create user-defined templates for Simulink models, see Create Template from Model.

After creating and saving a user-defined template, you can link the template to a Simulink behavior. Right-click the component and select Create Simulink Behavior, or, navigate to Modeling > Create Simulink Behavior.

Create Simulink Behavior for a component. Create the new model from a Simulink template and a new data dictionary.

On the Create Simulink behavior dialog, choose the template and enter a new data dictionary name if local interfaces are defined. Click OK. The component exhibits a Simulink behavior according to the template with shared interfaces, if present. Blocks and lines in the template are excluded, and only configuration settings are preserved. Configuration settings include annotations and styling.

Note that you can use architecture templates by right-clicking a component and selecting Save As Architecture Model, or navigating to Modeling > Save As Architecture Model.

Save component as an architecture model. Create the new model from a Simulink template and a new data dictionary.