System Composer

Introduction Workshop
Using System Composer to generate a system architecture from a set of requirements.

Copyright ©2023 The MathWorks, Inc.

System Composer Introduction Workshop

Abstract
This case-study involves taking a set of predefined requirements for a quadcopter and modifying and
linking them to a new system architecture in System Composer. Various features of System
Composer will be explored ranging from requirements decomposition to SWAP-c analysis,
implementation in Simulink, and reporting. The methodology used by this workshop is
Requirements, Functional, Logical, Physical (RFLP) but System Composer can support many
different methodologies through the use of profiles and stereotypes.

Syllabus

• Requirements Definition

We will start off by looking at a pre-defined set of Stakeholder Requirements in Requirements

Toolbox. Next, we will import System Requirements with Custom Attributes, add an additional
requirement, and link to the stakeholder requirements.

• Architecture Creation
• Functional Architecture

Based off our requirements, we have an idea of what different functions our system needs to have
so we will create a functional decomposition and link a requirement to it.

• Requirements Linking to Architecture Models

Requirements Toolbox can be used for creating links between requirements and elements in
architecture diagrams which will be demonstrated in this section.

• Logical Architecture

The second type of architecture we will explore is the Logical Architecture which groups system
functions into a logical grouping (such as which software applications will be responsible for
executing each function).

• Sequence Diagram Co-authoring

Sequence diagrams are very useful to express expected behavior. While constructing a sequence
diagram, internal block diagrams are automatically created.

• Profiles

A new profile will be created with stereotypes to extend the architecture modeling language of
System Composer.

Copyright ©2023 The MathWorks, Inc. Page 2 of 83

System Composer Introduction Workshop

• Stereotype Customization

Stereotypes can be customized with unique colors and icons to make the Logical Architecture easier
to read and add additional properties to the components. Inheritance in stereotypes and the concept
of an abstract stereotype will also be explored.

• Allocations

The Allocation Editor is used to draw a digital thread between System Composer architecture
models. We will use the allocation feature to create a connection between the components in the
functional and logical architectures.

• Interfaces

Interfaces are used to describe the structure and data types of ports in System Composer. This
section will show how to create and assign interfaces to ports using the Interface Editor and Property
Inspector.

• Simulink Integration with System Composer and co-execution with

Sequence Diagrams

One of the methods of describing component behaviors in System Composer is by using Simulink
models. This section will demonstrate both creating new Simulink models from System Composer
(top-down) and linking existing reference models (bottoms-up).

• Dataflow Analysis Using Model Slicer

Dataflow analysis can be easily conducted in System Composer by right-clicking a connector and
selecting "Highlight Signal to Source" (or Destination) and then using the keyboard arrows to trace
the signal path as will be shown in this section.

• Physical Architecture

The third architecture type that we will look at is the physical architecture which describes the
tangible components in the system. The physical architecture in this workshop will be a pre-built
example that we will explore using the Views Gallery and then modify to add variants and conduct a
trade study.

• Views

Views in System Composer provide a query-based method to explore architecture models which
helps to make large, complex architectures more easily digestible and easier to work with. This
functionality will be used to generate and refine the serial communication topology for the physical
architecture.

Copyright ©2023 The MathWorks, Inc. Page 3 of 83

System Composer Introduction Workshop

• Variants

We will add two variant components to the Physical Architecture. The components will be based off
product sheets for two different Analog-to-Digital Converters (ADC).

• Analysis

System Composer has a powerful Analysis Iterator that will be used in this section to choose which
ADC variant best satisfies the needs of the system. We will go in-depth to how the Analysis Iterator
works and how to write an analysis function to perform a mass/cost/power roll-up for a SWAP-c
analysis.

• Reporting

Finally, we will look at the reporting capability to generate customer deliverables using the System
Composer report generator APIs as well as an interactive web view that can be shared with non-
`MATLAB users.

Copyright ©2023 The MathWorks, Inc. Page 4 of 83

System Composer Introduction Workshop

Table of Contents
Abstract .................................................................................................................................................. 2
Syllabus.............................................................................................................................................. 2
1.0 Requirements Definition................................................................................................................... 6
1.1 Import Requirements ................................................................................................................... 6
1.2 Adding a Requirement ............................................................................................................... 10
1.3 Linking Requirements ................................................................................................................ 11
2.0 Architecture Creation ..................................................................................................................... 13
2.1 Functional Architecture .............................................................................................................. 13
2.1.1 Child Architecture ............................................................................................................... 15
2.1.2 Requirements Linking to Architecture Models ................................................................... 17
2.1.3 Traceability Diagram ........................................................................................................... 20
2.2 Logical Architecture ................................................................................................................... 25
2.2.1 Sequence Diagram Co-Authoring ...................................................................................... 25
2.2.2 Building a Profile ................................................................................................................. 31
2.2.3 Assigning Stereotypes ........................................................................................................ 35
2.2.4 Allocations .......................................................................................................................... 39
2.2.5 Interfaces ............................................................................................................................ 43
2.2.6 Simulink Integration ............................................................................................................ 48
2.2.7 Sequence Diagram Execution ............................................................................................ 49
2.2.8. Dataflow analysis ............................................................................................................... 53
2.3 Physical Architecture ................................................................................................................. 55
2.3.1 Views .................................................................................................................................. 55
2.3.2 Variant Components ........................................................................................................... 58
2.3.3 Analysis .............................................................................................................................. 65
3.0 Reporting........................................................................................................................................ 74
3.1 Architecture Reports .................................................................................................................. 74
3.2 Architecture Diagrams as Webview........................................................................................... 74
3.2 Architecture Data (optional) ....................................................................................................... 76
3.3 Allocation Data (optional)........................................................................................................... 77
3.4 Requirements Export (optional) ................................................................................................. 77
3.5 Traceability Matrix (optional) ..................................................................................................... 78
4.0 Conclusion ..................................................................................................................................... 82

Copyright ©2023 The MathWorks, Inc. Page 5 of 83

System Composer Introduction Workshop

1.0 Requirements Definition

1. Unzip the following file to the Working directory or press Do it for Me!

RequirementsDefinition\RequirementsDefinition.zip

2. Launch the Requirements Toolbox Editor:

Click to Launch Editor

slreq.editor

Note: The requirements editor can also be launched through the System Composer GUI.

3. Open Working/1_StakeholderRequirements.slreqx in the requirements editor. These are the

customer requirements.

Do it for Me!

1.1 Import Requirements

We will import system requirements from an Excel spreadsheet.

To skip this section, click: Do it for Me!

1. Import the requirements set Working\2_SystemRequirements.xlsx.

Copyright ©2023 The MathWorks, Inc. Page 6 of 83

System Composer Introduction Workshop

2. Uncheck "Use Worksheet name as item ID prefix", select "Text only" and "Specify rows and
columns."

3. Press the "Configure columns" button to open the Configure columns GUI. Here we specify how to
read in the data.

4. Assign the following in the Use As: row:

"Category" to <Custom Attribute>, "ID" to Custom ID, "Summary" to "Summary", "Description"

to Description, and assign the remaining columns to <Custom Attribute>

5. Press OK to close the Configure columns GUI.

Copyright ©2023 The MathWorks, Inc. Page 7 of 83

System Composer Introduction Workshop

6. Uncheck "Allow updates from external source". If you plan to manage the requirements outside of
Requirements Toolbox and merge in changes, then select this option. If you intend to migrate your
requirements permanently from an external tool, uncheck this box.

7. Press Import

8. You should now have all of the requirements imported from the spreadsheet. If you select a
requirement, you will see all the properties of that requirement, including custom attributes, in the
property inspector on the right-hand side. You can also close Microsoft Excel at this point.

Copyright ©2023 The MathWorks, Inc. Page 8 of 83

System Composer Introduction Workshop

9. Right-click "Index" in the header row and choose "Select Attributes..."

10. Add the Category column immediately after the Index column and press OK. This will shows us
the requirement category attributes that were imported from the spreadsheet.

Copyright ©2023 The MathWorks, Inc. Page 9 of 83

System Composer Introduction Workshop

1.2 Adding a Requirement

To skip this section: Do it for Me!

1. Scroll down to the embedded controller category select the requirement at index 1.19.

2. Press the add requirement button to add a new embedded controller requirement after it.

3. Add the following requirement. You don't have to fill in the custom attributes (second row below)
but you can if you want:

Category Custom ID Summary Description

Embedded Controller EC-10 Analog Input The embedded controller shall have
an analog to digital converter for measuring sensor inputs.

Derived Applicable Spec Design Assurance Level Safety Related

Verification Method

Y DO-254/DO-160/MIL-STD-810G A Y
Examination

4. Save your work.

Copyright ©2023 The MathWorks, Inc. Page 10 of 83

System Composer Introduction Workshop

1.3 Linking Requirements

To skip this section: Do it for Me!

1. Click the Summary column header to sort by summary so that STAKEHOLDER-14 appears at the
top of the requirements list.

2. Scroll down to EC-04 (Embedded Controller Cost) and right click it.

3. Select "Select for linking with Requirement"

4. Scroll to the top and right-click STAKEHOLDER-14 and select "Create a link from EC-04 : Cost to
STAKEHOLDER-14 : Cost"

5. After linking is complete, select the Links view at the top of the requirement editor:

6. You should now be able to see the linkset and link that were created. Link type can also be
changed from this view. The default is "Related to".

Copyright ©2023 The MathWorks, Inc. Page 11 of 83

System Composer Introduction Workshop

Links also show up in the bottom-right of the requirements view when you select a requirement that
contains links.

7. Use the Save All button to save the requirement set and the new linkset.

Copyright ©2023 The MathWorks, Inc. Page 12 of 83

System Composer Introduction Workshop

2.0 Architecture Creation

2.1 Functional Architecture
With a set of system requirements established, we can start fleshing out the functional architecture.
The functional architecture breaks down the actions or verbs that a system must perform to
accomplish its goal. System Composer can be use to capture these functions, group them,
decompose complex functions, and allocate them to the other architectures.

1. Launch a blank System Composer Architecture Diagram from the Home tab of the ribbon in
MATLAB or by typing "systemcomposer" in the command window and pressing enter. Do it for Me!

2. Expand the System Composer tree and select Create Model by clicking on the Architecture Model
button. Do it for Me!

Other architecture templates available but not covered today:

Software Architectures

https://www.mathworks.com/help/systemcomposer/author-simulate-deploy-software-
architectures.html

AUTOSAR Architectures

https://www.mathworks.com/help/autosar/ug/create-architecture-models.html

Copyright ©2023 The MathWorks, Inc. Page 13 of 83

System Composer Introduction Workshop

3. Double-Click "untitled" on the top-left of the canvas and change the name to
FunctionalArchitecture.

4. Click and drag on the canvas to make a box.

5. Select "Component" to create a new component and name it "Identify Target Position"

Do it for Me!

Copyright ©2023 The MathWorks, Inc. Page 14 of 83

System Composer Introduction Workshop

6. Add components for the following additional items: Do it for Me!

• Identify Quadcopter Position

• Plan Movement
• Execute Movement
• Check Manual Inputs

Tip: You can press the space bar twice to fit the architecture to the window.

2.1.1 Child Architecture

To skip this section, press: Do it for Me!

1. Open the architecture of the "Identify Quadcopter Position" component by double-clicking it.

Copyright ©2023 The MathWorks, Inc. Page 15 of 83

System Composer Introduction Workshop

2. Add two child components, "Measure Position" and "Measure Altitude".

3. Press the save button.

This will be our functional architecture. Depending on your workflow, you may decide to add more
detail by further decomposing complex functions or connecting functions to create a functional flow
block diagram.

Copyright ©2023 The MathWorks, Inc. Page 16 of 83

System Composer Introduction Workshop

2.1.2 Requirements Linking to Architecture Models

Now that our functional architecture has been defined, lets create traceability from our system
requirements to our architecture. Requirements can be linked directly to System Composer
components and ports.

1. In the FunctionalArchitecture diagram, select the Apps tab in the ribbon and then Requirements
Manager.

2. In the requirements manager, open 2_SystemRequirements.slreqx which was created earlier in

this workshop.

3. To add columns, right-click one of the requirements in the requirements pane and choose "Select
Attributes"

4. If not already present, add the Description column and press "OK". Notice that all of the custom
attributes are also available to add if desired.

Copyright ©2023 The MathWorks, Inc. Page 17 of 83

System Composer Introduction Workshop

5. Resize the columns in the requirements pane by dragging the lines between the headers to make
them easier to read.

6. In the FunctionalArchitecture diagram, ensure that you are still in the "Identify Quadcopter
Position" architecture.

7. Click-and-drag SENS-03 from the requirements pane onto the "Measure Altitude" component.

8. Observe the requirements icon has been added in the top-right corner to show that the
component has a linked requirement.

9. Click the requirements icon and select "Show"

10. The requirement is now shown on the canvas and can be dragged around to move as
necessary.

Note: Deleting the requirement annotation from the canvas will not delete the link. The link can be
removed through the links view in the requirements pane or the standalone requirements editor.

Copyright ©2023 The MathWorks, Inc. Page 18 of 83

System Composer Introduction Workshop

11. Notice that when you click the requirement in the requirements pane, any components linked to
that requirement are highlighted on the canvas.

12. Link PERF-07 to "Measure Position" and PERF-08 to "Measure Altitude" and show them on the
chart. If not already present, add the "Implemented" column in the requirements pane and observe
that a roll-up percent implemented is shown graphically for the System Requirements. If you scroll
down, you will now see that PERF-07 and PERF-08 show as implemented.

Copyright ©2023 The MathWorks, Inc. Page 19 of 83

System Composer Introduction Workshop

2.1.3 Traceability Diagram

The traceability diagram shows you upward and downward traceability of a requirement.

1. Right-click the PERF-07 requirement in the requirement editor and select "View Traceability
Diagram".

The traceability diagram can be used for thread-pulling activities and shows artifact links by both
artifact and link type.

Copyright ©2023 The MathWorks, Inc. Page 20 of 83

System Composer Introduction Workshop

2. In the System Composer property inspector, change the description of PERF-07 to set the
position tolerance to 0.15 m instead of 0.1 m.

Copyright ©2023 The MathWorks, Inc. Page 21 of 83

System Composer Introduction Workshop

and save the requirements set

3. Press the "Analyze" button in the traceability diagram.

The diagram has been updated based on the changed requirement to show the suspect link. This
lets you know that the linked requirement has changed so the affect artifacts should be investigated.

5. Right-click on the link and choose "Navigate to: Link"

Copyright ©2023 The MathWorks, Inc. Page 22 of 83

System Composer Introduction Workshop

6. The suspect link can be cleared from the requirements editor by right-clicking it and selecting
"Clear Issue".

You need to enable the "Change Information" option below to see the details in the requirements
editor.

7. Enter a comment and press Clear Issue.

8. The comment is stored as a justification of the change impact in the "Comments" section of the
link.

Note: You might have to press "Analyze Now" during this step at the top of the Requirements
Editor if prompted.

Copyright ©2023 The MathWorks, Inc. Page 23 of 83

System Composer Introduction Workshop

9. Save Selected Link Set and close the traceability diagram.

10. Before starting with the next session, clear the workspace. To automate this step, press:
Do it for Me!

Copyright ©2023 The MathWorks, Inc. Page 24 of 83

System Composer Introduction Workshop

2.2 Logical Architecture

The logical architecture is used to group the functions according to a certain set of logical
subsystems. Multiple logical architectures may be designed to test different function allocations. The
logical architecture can represent things such as partitioned applications or other groupings of
functions intended to operate as a single unit. The logical architecture can then be decomposed
further into subsystem architectures, software architectures, or linked directly to behavioral models
that will be used for code generation and simulation. In this exercise, we will learn how to use the co-
authoring workflow of the sequence diagram to build our logical architecture.

2.2.1 Sequence Diagram Co-Authoring

Sequence diagrams can be used to describe intended interactions between existing architecture
elements and even create new ones. This is called the co-authoring workflow.

1. Unzip the following file to the Working directory or press Do it for Me!

FunctionalArchitecture\FunctionalArchitecture.zip

2. Create a new architecture model named LogicalArchitecture.slx and press the "Sequence
Diagram" button in the toolstrip.

3. Use the drop-down on the "New" button and select "Sequence Diagram" and name the diagram
"RotorSpeedControl".

Copyright ©2023 The MathWorks, Inc. Page 25 of 83

System Composer Introduction Workshop

4. Components are represented in the sequence diagram as lifelines. Use the Add Lifeline button
and add the following lifelines:

SensorAcquisition

SensorProcessing

RotorControl

5. Select the RotorControl lifeline and add a child lifeline called SpeedControl

6. Click and drag from from the SensorProcessing to SpeedControl lifeline. Enter "Altitude" for "To"
and "From". These represent the port names on the components in the architecture and the
connection represents the flow of processed altitude sensor data to the SpeedControl logical
component.

7. Create one more connection from SensorProcessing to SpeedControl, "AltitudeFault" which

represents a status message that is true if a fault is present and false if not.

Copyright ©2023 The MathWorks, Inc. Page 26 of 83

System Composer Introduction Workshop

8. Now, lets add triggers to the connections. Sequence diagrams are event-driven and require a
trigger condition to activate. A trigger can be a function call, a message, or a zero-crossing event
(rising/falling/crossing). For the first trigger, add the Altitude message as the trigger event. This
means that the first line will be triggered when the SensorProcessing component sends an Altitude
message to the SpeedControl component.

9. Add an additional trigger condition AltitudeFault.

10. If the trigger should only fire under certain conditions, a constraint can be added to the connector
in square brackets. This means that even if the trigger fires, the sequence is not activated unless the
constraint is also met. Add a constraint that AltitudeFault must be false (normal operation) for the
sequence to be satisfied.

Copyright ©2023 The MathWorks, Inc. Page 27 of 83

System Composer Introduction Workshop

11. As both Altitude and AltitudeFault events are triggered in parallel we need to add a fragment to
represent that. Left-click and drag on the canvas of the sequence diagram to draw a box around the
connections and then use the quick-insert menu (...) to add a Par Fragment.

Fragments in Sequence Diagrams can be used to denote further constraints of sequences such
as conditional (if-then), loop, and parallel. More information on fragments can be found at the link
below:

https://www.mathworks.com/help/systemcomposer/ug/sequence-diagram-fragments-for-message-
ordering.html

Copyright ©2023 The MathWorks, Inc. Page 28 of 83

System Composer Introduction Workshop

12. Next, select the Par Fragment then press "Add Operand" on the toolstrip.

13. Finally, single left-click the canvas to deselect everythen and then drag the AltitudeFault
connector from the top operand to the bottom one to denote that these are separate, parallel
sequences.

Copyright ©2023 The MathWorks, Inc. Page 29 of 83

System Composer Introduction Workshop

14. Save the model and close the Architecture Views Gallery

Notice after you close the gallery, that components, ports, and connectors were automatically added
to the architecture model while we built the sequence diagram. This is the co-creation workflow.

Copyright ©2023 The MathWorks, Inc. Page 30 of 83

System Composer Introduction Workshop

15. Left-click and drag from the right edge of the SensorAcquisition component to the left edge of the
SensorProcessing component to add one more connection and name it "Atitude_Raw". This will
represent the flow of continuous signal data acquired by the sensor to the rest of the system.

2.2.2 Building a Profile

You can extend your architecture model using profiles and stereotypes. Profiles are stored as xml
files and contain collections of stereotypes that can be used to add metadata to your model

Copyright ©2023 The MathWorks, Inc. Page 31 of 83

System Composer Introduction Workshop

elements. Stereotypes can have additional attributes associated with them such as styling
information and user-specified properties.

1. To create a new profile, press the Profile Editor button in the PROFILES section of the Modeling
tab in the System Composer toolstrip.

2. Create a new profile and name it "LogicalProfile"

3. Add a new stereotype and name it "LogicalComponent"

4. Stereotype Attributes:

Set the "Applies to" attribute to "Component". This means the stereotype can only be applied to
components.

Base Stereotype: <nothing> - This can be used to allow this stereotype to inherit attributes and
properties from another stereotype. Keep it blank.

Abstract Stereotype: unchecked - Abstract stereotypes cannot be applied directly to model

elements, only used as a base for other stereotypes. Keep it unchecked.

Default Stereotypes for Composition: none - When the stereotype has an "Applies to" attribute
value of "Component", this list of defaults can be specified for which stereotypes to automatically
apply to any child elements created directly inside that component. Keep this blank.

Copyright ©2023 The MathWorks, Inc. Page 32 of 83

System Composer Introduction Workshop

5. Stereotype Properties:

Add some properties that you might expect a logical component to have. See below for an
example.

Properties can have names, data types, units, and default values.

6. Notice that if you set a property data type to enumeration, you are prompted to enter the name of
the enumeration class.

If the enumeration is not found on the path, it can be created

Copyright ©2023 The MathWorks, Inc. Page 33 of 83

System Composer Introduction Workshop

7. Save and close then enumeration and then set the default value for the property to "Unset".

Note: If the values are stale (Red, Green, Blue) then choose a stale value and the field will update so
that you can then choose the correct value.

8. Create three additional stereotypes: InputOutput, SignalProcessing, and ControlLaw, set their
base type to LogicalComponent, and give them unique colors and icons.

Notice that if you check the "Show Inherited Properties" box at the bottom, properties that are
inherited from the base stereotype are displayed as read-only in the property editor panel.

9. Save the profile in the working directory.

Copyright ©2023 The MathWorks, Inc. Page 34 of 83

System Composer Introduction Workshop

10. Now that the profile has been created, it can be associated with architecture models. Use the
"Import into" drop-down to make the profile available for use in the logical architecture.

11. Close the Profile Editor and navigate back to the logical architecture.

2.2.3 Assigning Stereotypes

Stereotypes can be applied to the elements in the architecture model to "type" them with additional
metadata.

There are three primary ways to assign stereotypes:

1. From the logical architecture, right-click the SensorAcquisition component and apply the
InputOutput stereotype.

Copyright ©2023 The MathWorks, Inc. Page 35 of 83

System Composer Introduction Workshop

2. Select the SensorProcessing component and use the property inspector to apply the
SignalProcessing stereotype.

3. Select the RotorControl component and then press the "Apply Stereotypes" button in the toolstrip
then use the batch apply GUI to apply the ControlLaw stereotype to the current selection.

Copyright ©2023 The MathWorks, Inc. Page 36 of 83

System Composer Introduction Workshop

4. Stereotype property values can be uniquely set for each element. Set one of the property values
for all three of the components in the architecture model using the property inspector.

5. Press the spacebar twice to fit the architecture to view and then save the model.

Copyright ©2023 The MathWorks, Inc. Page 37 of 83

System Composer Introduction Workshop

Copyright ©2023 The MathWorks, Inc. Page 38 of 83

System Composer Introduction Workshop

2.2.4 Allocations

Multiple architecture models may be used to represent different abstractions of the same system.
For example, a functional architecture, and a logical architecture. Allocations can be used to create a
digital thread between these.

1. From System Composer, press the "Allocation Editor" button in the VIEWS section of the
Modeling Tab

2. Press "New Allocation Set"

3. Name the new allocation set FunctionToLogical and choose the functional architecture as the
allocation source and the logical architecture as the allocation target.

4. Allocations are divided into scenarios that can be used to represent different combinations of
allocations between the source and target architectures. For example, different product lines,
different versions of a product, or different allocation trade studies. In this workshop, we will only use
one allocation scenario.

Copyright ©2023 The MathWorks, Inc. Page 39 of 83

System Composer Introduction Workshop

5. Allocation sets can be filtered using the ribbon on element type or assigned stereotype. Select
"Component" for both the row filter and the column filter.

6. In the filtered allocation table, double-click in the matrix to allocate Measure Altitude to
SensorAcquisition and Plan Movement to SensorProcessing:

7. Now click "Execute Movement" in the first column to open the functional architecture.

8. Use the context menu to set the Execute Movement function as the allocation source.

Copyright ©2023 The MathWorks, Inc. Page 40 of 83

System Composer Introduction Workshop

9. Open the logical architecture and use the context menu to allocate the Execute Movement
function to the RotorControl component.

10. Allocations can also be included on the architecture model. To enable allocation badges, go to
the System Composer toolstrip and press the Allocation Editor drop-down then select "Show
Allocations".

Copyright ©2023 The MathWorks, Inc. Page 41 of 83

System Composer Introduction Workshop

Allocation badges are shown on components that have been allocated to (down, target) and from
(up, source). Clicking the allocation badge shows you the loaded scenario and allocation as well as
a hyperlink to navigate to that model.

11: Click the hyperlink to navigate to the functional architecture and turn on allocation badges.
Notice that the badge points upward which shows that these components are allocation sources.

Note: Components can have both badges which represents that they are allocation sources and
allocation targets. Allocation badges are only shown for allocation sets that are currently loaded in
the allocation editor.

12. Save the allocation set and functional and logical architectures.

Copyright ©2023 The MathWorks, Inc. Page 42 of 83

System Composer Introduction Workshop

2.2.5 Interfaces

The interface editor in System Composer can be used to create and assign interfaces. Interfaces
can be used to define the structure and type of data that will be traveling in and out of the ports.
There are four types of interfaces in System Composer.

1. Composite Data Interface - A structured interface with multiple elements (such as a bus or
message) that supports nesting
2. Value Type interfaces for scalar or homogenous data (such as a single signal or array)
3. Physical Interface - A structured interface of Simscape physical signals such as mechanical,
electrical, and hydraulic (this interface is only found in the generic template)
4. Client-Server Interface - A call/response interface specific to function calls in software
architectures (this interface is only found in the software architecture template)

Interfaces can be shared or owned. Shared interfaces are defined in the data dictionary and can be
used to type multiple ports across components, architectures, and even Simulink models. Owned
interfaces are defined directly on the port and cannot be reused by other components and ports
(better for one-off interface definition).

For this workshop, we will just be using shared Value Type interfaces.

1. Open the Logical Architecture in System Composer and open the interface editor from the
DESIGN section of the Modeling tab (the interface editor might already be opened but collapsed at
the bottom of System Composer).

2. Use the New Interface drop-down to create a Value Type interface.

Copyright ©2023 The MathWorks, Inc. Page 43 of 83

System Composer Introduction Workshop

3. Name the interface Altitude, leave the Type of double and Dimensions of 1 and give it units of ft.

4. Create an additional Value Type named Fault of type boolean and enter "true = fault" in the
description field. This lets the other engineers know that when the value is true, a fault has been
detected by the system.

5. There are three ways to assign interfaces. Lets try all three! Select the SensorAcquisition
component's Altitude_Raw port then right-click the "Altitude" interface and select "Assign to Selected
Port(s)".

Copyright ©2023 The MathWorks, Inc. Page 44 of 83

System Composer Introduction Workshop

6. Select the "Altitude" interface in the interface editor then right-click the SensorProcessing Altitude
port and choose "Apply selected interface: Altitude".

7. Select the AltitudeFault port on the SensorProcessing component and use the Property Inspector
to apply the Fault interface.

8. Select the Altitude interface in the interface editor and notice that the ports where it has been
assigned are highlighted.

Notice also that the other connected ports are also highlighted which shows that the interface has
propagated across the connector to any other ports that did not have an interface assigned to them.

Copyright ©2023 The MathWorks, Inc. Page 45 of 83

System Composer Introduction Workshop

9. The opposite also works. Click on the canvas to clear the highlighting then select the AltitudeFault
port on the SensorProcessing component.

Notice that the Fault interface is highlighted in the interface editor.

Different Interfaces can also be connected using the interface adapter component or dot notation on
the architecture ports, for example, to only select specific messages off of a composite message
bus, or to concatenate messages or signals from multiple sources onto a composite interface. For
more information on interfaces, check out the help documentation:

https://www.mathworks.com/help/systemcomposer/ug/define-port-interfaces-between-
components.html

10. Interfaces can also be saved to an external data dictionary that can be shared across System
Composer models, Simulink models, and even referenced by other dictionaries as a single source of
truth for interface definition. Use the interface editor to save the interfaces to a data dictionary
named SystemInterfaces:

Copyright ©2023 The MathWorks, Inc. Page 46 of 83

System Composer Introduction Workshop

11. Save the logical architecture.

Copyright ©2023 The MathWorks, Inc. Page 47 of 83

System Composer Introduction Workshop

2.2.6 Simulink Integration

There are two main workflows for referencing Simulink models or other architectures: top-down or
bottoms-up. In the top-down workflow, you right-click the component and choose "Save as
Architecture" or "Create Simulink Behavior" (or other supported types). When you do that, the data
dictionary will be linked to the newly-created skeleton model which can then be further decomposed.
With bottom-up workflows you can instead link existing models to the components in your
architecture. Architecture models can be linked in a similar way. In this workshop, we will continue
using the top-down workflow.

1. Right-click the SensorAcquisition component and choose "Create Simulink Behavior..."

After that you can choose to create the Simulink behavior as a model reference (externally stored),
subsystem reference (externally stored), or a virtual subsystem (internally stored). Select Model
Reference for this behavior and press OK.

Notice that the component now has an external reference behavior as denoted by the Simulink
badge and external model name in angle brackets. Double-click the component and observe that

Copyright ©2023 The MathWorks, Inc. Page 48 of 83

System Composer Introduction Workshop

you have transitioned seamlessly from architecture modeling in System Composer to behavioural
definition in Simulink.

2. Before starting with the next session, clear the workspace. To automate this step, press:
Do it for Me!

2.2.7 Sequence Diagram Execution

System Composer Sequence Diagrams can be used as a verification tool to determine if the linked
behaviors in the integration model achieve the diagramed sequences. This section demonstrates
how to execute sequence diagrams alongside the architecture model and interpret the results.

1. Unzip the following file to the Working directory or press Do it for Me!

LogicalArchitecture\LogicalArchitecture.zip

2. In your LogicalArchitecture, all components have now been linked to Simulink behaviors,
representing the integration phase of your system development.

If you double-click on any of the components, you can now edit the behavioral model directly in
Simulink.

Copyright ©2023 The MathWorks, Inc. Page 49 of 83

System Composer Introduction Workshop

Note: The following steps in Sequence Diagram Execution are optional during this workshop
depending on time.

3. Open the Architecture Views Gallery and navigate to the RotorSpeedControl sequence diagram.

4. Press the Run button to execute the architecture model against the RotorSpeedControl sequence
diagram.

5. The results below show that both of these events occurred at least once during the execution of
the architecture model as denoted by the green check boxes.

Copyright ©2023 The MathWorks, Inc. Page 50 of 83

System Composer Introduction Workshop

Question: What if these conditions are supposed to always be true, not just once?

6. Select the RotorSpeedControlLoop sequence diagram and press the Run button again. This
sequence diagram wraps a Loop fragment around the existing sequence.

Question: Why do you get a fault in this sequence diagram?

Copyright ©2023 The MathWorks, Inc. Page 51 of 83

System Composer Introduction Workshop

7. Lets use the sequence viewer to investigate what happened. Navigate to the logical architecture
and launch the Sequence Viewer from the REVIEW RESULTS section of the SIMULATION tab in
the toolstrip.

The sequence viewer can be used to visualize event-based data exchanged during the model
execution such as messages and function triggers.

More information on the sequence viewer can be found at the following link:

https://www.mathworks.com/help/simulink/slref/sequenceviewertool.html

8. The sequence viewer reveals to us that the system received a bad altitude (-999) and the fault
detection logic was activated which culminated as a failure in our RotorSpeedControlLoop sequence
diagam above.

Question: What can you do to depict these different scenarios in the sequence diagram?

Copyright ©2023 The MathWorks, Inc. Page 52 of 83

System Composer Introduction Workshop

9. Return to the Architecture Views Gallery of the logical architecture and select the
RotorSpeedControlLoopFaults sequence diagram. This diagram uses an Alt fragment (if-else) to
specify the behaviors at each of the signal boundary conditions (low, high, in-range).

10. Press the Run button to execute the architecture model against the sequence diagram.

Question: Why is the condition Altitude_Raw > 50000 not triggered?

11. Close the Architecture Views Gallery and save the logical architecture.

2.2.8. Dataflow analysis

As a systems engineer, it is a common task to study the flow of data across an architecture. System
Composer helps you trace signals through both you architectural (System Composer) and
behavioral (Simulink) models.

1. To start a data trace, right-click a connector and choose "Highlight Signal to Destination". The
Altitude_Raw data will be used for this example.

Copyright ©2023 The MathWorks, Inc. Page 53 of 83

System Composer Introduction Workshop

2. Use the right and left arrow keys on the keyboard to trace the signal to its source or destination
and understand how it propagates across the system.

3. When you are finished, press the X in the top-right of the main viewer to exit the tracing view.

Before starting with the next session, clear the workspace. To automate this step, press: Do it
for Me!

Copyright ©2023 The MathWorks, Inc. Page 54 of 83

System Composer Introduction Workshop

2.3 Physical Architecture

We will now open a prebuilt physical architecture, explore different ways to visualize the architecture,
add variant choices to some of the physical components, and finally perform a trade study using the
analysis iterator.

1. Unzip the following file to the Working directory or press Do it for Me!

PhysicalArchitecture\PhysicalArchitecture.zip

2.3.1 Views

In this section, we will use the Architecture Views Gallery to visualize the topology of our serial (I2C)
communication network.

1. Open the Architecture Views gallery in the physical architecture.

2. Open the pre-built I2C view. This is a query-based filter view. The existing query can be seen in
the View Configurations pane at the bottom.

Copyright ©2023 The MathWorks, Inc. Page 55 of 83

System Composer Introduction Workshop

3. Besides component filters, you can also add port filters to further refine the view. Add a port filter
for the I2C stereotype then press "Apply".

The new view filters the rest of the architectural elements to cleanly depict our serial communcation
network topology.

Copyright ©2023 The MathWorks, Inc. Page 56 of 83

System Composer Introduction Workshop

4. Save the model and close the Architecture Views Gallery.

Copyright ©2023 The MathWorks, Inc. Page 57 of 83

System Composer Introduction Workshop

2.3.2 Variant Components

The sensors in this physical architecture have analog outputs which need to be converted to I2C for
the embedded controller. We will use an Analog-to-Digital converter to take care of the conversion.
We have two different A2D choices to decide between so we will add them both as variants and then
use the analysis iterator in System Composer to choose the optimal part.

1. Open the Quadcopter subsystem and then open the Sensor System subsystem.

2. Draw a new Component on the canvas named "Analog to Digital Converter".

Copyright ©2023 The MathWorks, Inc. Page 58 of 83

System Composer Introduction Workshop

3. Connect the I2C bus, power bus, and analog signals to the component (you may have to make
the component taller to fit all the ports).

4. Now that our base component has been created, lets add variation to it. Right-click the Analog to
Digital Converter and select "Add Variant Choice".

Copyright ©2023 The MathWorks, Inc. Page 59 of 83

System Composer Introduction Workshop

This opens up the variant editor. Each component you add here becomes a possible design
choice that can be switched between. Also notice how all the signals that were connected to the first
component have also been added as inputs to the new variant. Variants allow you to create
configuration options within your model. The active variant is shown in normal color and all the other
variant choices are greyed out.

5. Name the two components AD12201C and A2D-08-08-01 by single-clicking each component then
entering its name either directly on the canvas or in the Property Inspector pane.

Copyright ©2023 The MathWorks, Inc. Page 60 of 83

System Composer Introduction Workshop

Copyright ©2023 The MathWorks, Inc. Page 61 of 83

System Composer Introduction Workshop

6. Assign the stereotype PhysicalProfile.PhysicalProperties to each of the two components and then
populate the property values based on the datasheets below.

Manufacturer Signal Specialists Circuit Pro

Part number AD12201C A2D-12-08-01

Mass 0.1 kg 0.1 kg

Cost $3 USD $6 USD

Input Power 12 VDC 12 VDC

Power Consumption 3W 1.5 W

Analog Inputs 12 x -10 V to 10 V 12 x 0 V to 10 V

Analog Input Resolution 32 bits 16 bits

Analog Outputs 2 x -10 V to 10 V 8 x 0 V to 10 V

Analog Output Resolution 32 bits 16 bits

Digital I/O 1 x I2C 1 x I2C

Copyright ©2023 The MathWorks, Inc. Page 62 of 83

System Composer Introduction Workshop

7. Press the X in the top-right of the canvas to exit variant creation mode.

8. Return to the sensor system.

9. Ensure that AD12201C is the active choice by right-clicking the Analog to Digital Converter
component and confirming that there is a check mark next to AD12201C. Enable it if not.

Copyright ©2023 The MathWorks, Inc. Page 63 of 83

System Composer Introduction Workshop

Note: If you select "Open in Variant Manager," you can rename "Choice" and "Choice_1" to
some other option such as "HighPerformance" or "LowPerformance" etc. We will leave it as-is for
this workshop. Using the Variant Manager also requires installation of the variant manager support
package.

https://www.mathworks.com/products/simulink-variant-manager.html

11. Before starting with the next session, clear the workspace. To automate this step, press:
Do it for Me!

Copyright ©2023 The MathWorks, Inc. Page 64 of 83

System Composer Introduction Workshop

2.3.3 Analysis

We will now conduct a bottom-up analysis to determine which Analog to Digital converter to choose.
Conducting a bottom-up analysis will result in the lowest-level components (and/or interfaces, ports,
and connectors) being passed to the analysis function first and then the next level up and so on until
reaching the top of the architecture tree. This means that the analysis function is called once for
each component passed to it. It also make conducting roll-ups easy because rather than writing a
recursive loop, we only have to write a simple For loop to check the next-lowest level when we
encounter a parent component and the analysis iterator will handle the rest of the recursion for us.

1. Unzip the following file to the Working directory or press Do it for Me!

PhysicalArchitecture\PhysicalArchitectureAnalysis.zip

2. Select "Analysis Model" on the ribbon (Modeling tab, VIEWS section) of the physical architecture.

3. Select the PhysicalProperties stereotype for the analysis (contains cost/mass/power), specify
Strict Mode to only include components with that stereotype assigned, set the iteration order to
Bottom-up.

4. Type the name of the included analysis function, "RollUpFunction" (click to view). This function
gets called iteratively by the Analysis tool. Each time it is called, a new component is passed to it
according to the specified iteration order.

Copyright ©2023 The MathWorks, Inc. Page 65 of 83

System Composer Introduction Workshop

ASIDE ON ANALYSIS FUNCTIONS

Note: If not using a pre-built analysis function, you can type a new function name then press the
green plus button. MATLAB will create a skeleton to help you get started based on the stereotypes
that you selected.

Here is the skeleton based on our current configuration:

function RollUpFunction(instance,varargin)
% RollUpFunction Example Analysis Function

if instance.isComponent()
PhysicalProperties_Cost =
instance.getValue("PhysicalProperties.Cost");
PhysicalProperties_Mass =
instance.getValue("PhysicalProperties.Mass");
PhysicalProperties_PowerConsumption =
instance.getValue("PhysicalProperties.PowerConsumption");
if isempty(instance.Components)
else

Copyright ©2023 The MathWorks, Inc. Page 66 of 83

System Composer Introduction Workshop

end
end
end

If you are trying to understand which order the iterator travels, the simple analysis function below will
print the architectural element names to the MATLAB command window as they are visited by the
iterator:

function IterOrder(instance,varargin)
disp(instance.Name);
end

NOTE: The pre-built analysis function is also included below for reference. Debug lines have been
included and commented out to help visualize what is taking place during the analysis. Breakpoints
can also be set in the .m file to pause the analysis which allows exploring the working variables at
that point.

function RollUpFunction(instance,varargin)
% RollUpFunction: Analysis Function to roll up the stereotype property
% values of the PhysicalProperties stereotype:
% Cost, Mass, and PowerConsumption

% This line will display "iter" in the command window each time this
% function is called, for debugging purposes.
% disp("iter");

% Only execute the following code if the instance is a component

% (ignore ports, connectors, and interfaces).
if instance.isComponent()

% Check to see if this component has the "PhysicalProperties"

% stereotype assigned to it. Otherwise, do nothing.
componentType = instance.Specification.getStereotypes;

if componentType == "PhysicalProfile.PhysicalProperties"
% This line will display the name of the current component
% being iterated on, for debug purposes.
% disp("Component: " + instance.Name);

% If this component has children then the script will iterate

% through the children and add their values to the parent
% component.
if ~isempty(instance.Components)
% Create placeholders to sum up the values from the child
% parts.
Parent.Cost = 0;

Copyright ©2023 The MathWorks, Inc. Page 67 of 83

System Composer Introduction Workshop

Parent.Mass = 0;
Parent.PowerConsumption = 0;

% Iterate through the children of this component.

for Component = instance.Components
% Display the name of the child being iterated on, for
% debug purposes.
% disp(" Child:" + Component.Name);

% Get the stereotype property value of the child.

Child.Cost = Component.getValue("PhysicalProperties.Cost");
Child.Mass = Component.getValue("PhysicalProperties.Mass");
Child.PowerConsumption =
Component.getValue("PhysicalProperties.PowerConsumption");

% Add the stereotype property value of the child to the

% placeholder for the parent value.
Parent.Cost = Parent.Cost + Child.Cost;
Parent.Mass = Parent.Mass + Child.Mass;
Parent.PowerConsumption = Parent.PowerConsumption +
Child.PowerConsumption;
end

% Set the value of the parent property based on the sum of

% the child properties stored in the placeholder.
setValue(instance, "PhysicalProperties.Cost", Parent.Cost);
setValue(instance, "PhysicalProperties.Mass", Parent.Mass);
setValue(instance, "PhysicalProperties.PowerConsumption",
Parent.PowerConsumption);

% The else condition can be used for debug to see if the

% component was rejected as a parent.
%else
% disp("singular");
end
end

end
end

More information on analysis functions can be found here:

https://www.mathworks.com/help/systemcomposer/ug/analysis-function-constructs.html

END OF ASIDE

Copyright ©2023 The MathWorks, Inc. Page 68 of 83

System Composer Introduction Workshop

5. After specifying the analysis function, press the Instantiate button:

The Analysis Viewer opens and displays the current stereotype property values. Notice how the
parent properties were intentionally left blank by the systems engineer when the stereotypes were
assigned. Any changes made programmatically or manually in the analysis viewer will NOT update
in the model unless you press the "Update" button. This analysis instance is just an instantiation of
the model, not the actual model. Likewise, if changes are made to the model, it is necessary to press
the "Refresh" button to pull those changes into the Analysis Viewer.

Copyright ©2023 The MathWorks, Inc. Page 69 of 83

System Composer Introduction Workshop

6. Press the Analyze button to run the analysis function.

7. Observe that a full roll-up has been conducted:

Copyright ©2023 The MathWorks, Inc. Page 70 of 83

System Composer Introduction Workshop

8. Save this instance model and analysis results as Rollup1.mat in the working directory.

9. Close this analysis and change the variant in the Sensor System to the other Analog to Digital
converter.

10. Press "Analysis Model" button again and set the properties as before. This time, the existing
RollUpFunction.m can be found using the folder icon.

Copyright ©2023 The MathWorks, Inc. Page 71 of 83

System Composer Introduction Workshop

11. Overwrite the existing analysis (its okay, we saved it for reference later).

12. Press the Analyze button.

13. Observe that the analysis has been updated with the new results.

Copyright ©2023 The MathWorks, Inc. Page 72 of 83

System Composer Introduction Workshop

The analysis has shown us that by using the second Analog-to-Digital converter, we pay a slightly
higher price but the power consumption of the system drops below the 500 Watt threshold.

Variant Cost Mass Power Consumption

Previous Roll-Up: AD12201C 413 9.9 501

New Roll-Up: A2D-12-08-01 416 9.9 499.5

11. Save this file as Rollup2.mat in the working directory and close the Analysis Viewer.

12. Before starting with the next session, clear the workspace. To automate this step, press:
Do it for Me!

Copyright ©2023 The MathWorks, Inc. Page 73 of 83

System Composer Introduction Workshop

3.0 Reporting
3.1 Architecture Reports
Now that all of these artifacts have been created in System Composer and Requirements Toolbox,
we will now look at how Simulink Report Generator can be used to generate documentation and
reports for sharing with stakeholders and other team members who do not have access to System
Composer..

1. Unzip the following file to the Working directory or press Do it for Me!

Complete\Complete.zip

2. Open GenerateArchitectureReport.mlx from the working directory.

GenerateArchitectureReport;

3.2 Architecture Diagrams as Webview

There may be a need to just share an architecture diagram with a colleague, in that case you may
want to consider these options.

1. Open the LogicalArchitecture, go to the SIMULATION tab and press Save and select Web View...

2. The Web view GUI has the option to package the web view as a zip file, unzipped or both. Select
the option unzipped.

Copyright ©2023 The MathWorks, Inc. Page 74 of 83

System Composer Introduction Workshop

3. The Web view GUI has multiple self-explanatory options for what to export. We will choose for
Entire Model, and Package Type Unzipped.

There are additonal items such as requirementslinks which can also be included in the report.

4. Press the Export button, close the web browser will be opened after the export.

5. Open webview.html from the LogicalArchitecure directory in MATLAB and observe how the output
starts at the top-level and then breaks down into each subsystem recursively. Also relevant data
such as interfaces and stereotypes can be displayed in the exported Architecture model.

Copyright ©2023 The MathWorks, Inc. Page 75 of 83

System Composer Introduction Workshop

3.2 Architecture Data (optional)

Data associated with the architecture such as components, connections, port interface data,
stereotypes and property values, can be exported via an API to System Composer. The following
lines of code export the FunctionalArchitecture to the MATLAB workspace and then save that data to
a Microsoft Excel file, FunctionalArchitecture.xls.

exportedSet = systemcomposer.exportModel("FunctionalArchitecture.slx");

SaveToExcel('FunctionalArchitecture',exportedSet);

The exported set has the following tables which become individual sheets in Microsoft Excel.

It is possible to save them individually also using MATLAB's writetable command. The following code
example will save :

exportedSet = systemcomposer.exportModel("FunctionalArchitecture.slx");

writetable(exportedSet.portInterfaces, "FunctionalArchitecture_Interfaces.xls")

Copyright ©2023 The MathWorks, Inc. Page 76 of 83

System Composer Introduction Workshop

3.3 Allocation Data (optional)

Allocation data can be accessed using the allocation APIs below and then processed for export.

allocSet = systemcomposer.allocation.load('FunctionalToLogical');

allocScenario = allocSet.getScenario('Scenario 1');

3.4 Requirements Export (optional)

Reports for requirements can be created from the requirements editor.

1. Open the 2_SystemRequirements.slreqx

2. Press the Export button and then choose option "Generate Report"

3. Specify the desired options then press Generate Report.

4. The report has now been output to slreqrpt_YYYYMMDD.docx

Copyright ©2023 The MathWorks, Inc. Page 77 of 83

System Composer Introduction Workshop

3.5 Traceability Matrix (optional)

Requirement traceability matrices can be created in Simulink Requirements.

1.From Simulink Requirements, press the Tracebility Matrix button.

2. Press the Add button on the top-left.

Copyright ©2023 The MathWorks, Inc. Page 78 of 83

System Composer Introduction Workshop

3. Press "Select Multiple Artifacts". We will create a 1x2 traceability matrix showing the full
traceability of our System Requirements.

4. Press the red Xs to get rid of the default artifacts.

5. In the left pane, right-click "2_SystemRequirements" and select "Add to the left".

6. Right-click "1_StakeholderRequirements.slreqx" and choose "Add to the top".

7. Right-click "FunctionalArchitecture.slx" and again choose "Add to the top".

8. Once the matrix has been configured, press the "Generate Matrix" button.

Copyright ©2023 The MathWorks, Inc. Page 79 of 83

System Composer Introduction Workshop

4. A view similar to the allocation view is shown. In this table, we can now see both the parent
requirement links and the implementation links associated with the System Requirements.

5. You can also use the Traceability Matrix for conducting requirements coverage analysis by
filtering or highlighting missing links. Press "Highlight Missing Links" to show any uncovered
requirements.

Copyright ©2023 The MathWorks, Inc. Page 80 of 83

System Composer Introduction Workshop

Links can also be created in this view:

5. To save the matrix, press Export and Generate HTML Report. Save the report with the default
name, SLReqMatrixSnapShot.html, in the working directory.

The matrix is saved to an HTML file which can be included as supplemental data to a customer
deliverable:

Copyright ©2023 The MathWorks, Inc. Page 81 of 83

System Composer Introduction Workshop

4.0 Conclusion
Thank you for taking the time to go through this workshop with us! This workshop has demonstrated
use of System Composer as a System Engineering tool to create various types of diagrams, link with
requirements and models, add properties to model components, allocate to other diagrams, perform
variant analyses, and export the data for delivery to the customer or suppliers. Please let us know
any feedback to help improve future iterations.

Due to time constraints of this workshop, not all features could be explored. Some of the functionality
not covered but available includes:

Simulating Architecture Behavior through System Composer:

https://www.mathworks.com/help/systemcomposer/ug/mobile-robot-workflow.html

Copyright ©2023 The MathWorks, Inc. Page 82 of 83

System Composer Introduction Workshop

Requirements-Based Testing

https://www.mathworks.com/help/slrequirements/requirements-based-verification.html

Constructing Software Architectures:

https://www.mathworks.com/help/systemcomposer/ug/author-software-architectures.html

Copyright ©2023 The MathWorks, Inc. Page 83 of 83