Can System Composer or other MathWorks tools be used to create Product Line Models (some call them Feature Models)?

I would like to create a product line model (feature models) as shown in this link Nomagic. My desire is to create a product line model and then choose variants of features to generate specific product architectural model(s) and continue to use the MathWorks tool chain to deploy embedded code to the product.

Answer 1

[Josh Kahn]

Hi Brian,

Yes, this can be done using System Composer. Feel free to reach out to us through your sales rep if interested in having a deeper technical discussion on feature modeling.

I listed two possible solutions below but there are many different approaches:

Solution 1 Using Variants

First, create your basic architecture model, in System Composer.

Then add variant components to it that represent your features (Leave a component called "Null" or something as one of the options):

https://www.mathworks.com/help/systemcomposer/ref/variantcomponent.html

The Variant Manager can then be used to define feature sets:

https://www.mathworks.com/help/simulink/gui/variant-manager-overview.html

You can then create a filter view of the architecture that excludes components named "Null"

https://www.mathworks.com/help/systemcomposer/ug/creating-architecture-model-views.html

Solution 2 Using Allocations

Create a full architecture model with all possible features included

Create an architecture model that represents your product (can just be an empty architecture named "Product").

Create an allocation set from your full architecture to your product architecture

https://www.mathworks.com/help/systemcomposer/ug/allocations-interactive-example.html

add a scenario to the allocation set for each product variant

allocate features to the product

Create a custom views query that filters the full architecture model based on what has been allocated in the specific set (this step is a little advanced)

[Brian]

Josh,

Thank you for the information and answer. I will be contacting our sales rep for further info.

Answer 2

[Hassaan]

Creating a product line model, particularly for systems that will eventually involve embedded code generation, is a multifaceted process that requires careful planning and tool integration. Here's a general approach to create a product line model and then use variants of features to generate specific product architectural models, with a pathway towards deploying embedded code:

1. Define the Product Line Model

• Identify Features: Start by identifying all the possible features in your product line. This includes hardware components, software functionalities, and any other relevant aspects.
• Create Feature Models: Use a modeling tool to create feature models. This could be done in tools like NoMagic's MagicDraw or other similar tools that support feature modeling and variability management.

2. Model Variants

• Define Variability: Once your feature models are established, define the variability mechanisms (like optional features, alternative features, etc.).
• Create Variant Models: Use these variability definitions to create variant models. Each variant model represents a specific configuration of the product line.

3. Integration with MathWorks Tools

• Simulink for System Modeling: For the system and architectural modeling, use Simulink. It provides a robust environment for modeling, simulating, and analyzing multidomain dynamical systems.
• Custom Blocks for Feature Variability: Implement custom Simulink blocks or use variant blocks to represent different feature choices in your models.

4. Linking to Embedded Code Generation

• Embedded Coder for Code Generation: Utilize MathWorks' Embedded Coder for generating C and C++ code from Simulink models. This tool is specifically designed for embedded systems.
• Validate the Model: Before code generation, thoroughly validate the Simulink model through simulation and testing to ensure that it behaves as expected for each product variant.
• Configure for Different Variants: Set up the Embedded Coder to handle different variants. This might involve configuring different build settings or parameters based on the selected features.

5. Automation and Continuous Integration

• Automate the Process: Consider automating the process from feature selection to code generation, especially if you have a large number of variants. This could involve scripting in MATLAB or integrating with other automation tools.
• Continuous Integration: For larger projects, set up a continuous integration system that automatically tests and builds your embedded code for different variants.

Considerations

• Manage Complexity: As product lines can become complex, use modular design principles to manage this complexity.
• Documentation: Keep comprehensive documentation for each stage of the process.
• Collaboration: Ensure that teams working on different aspects of the product line are in sync, especially when changes are made to the feature models.

---------------------------------------------------------------------------------------------------------------------------------------------------

If you find the solution helpful and it resolves your issue, it would be greatly appreciated if you could accept the answer. Also, leaving an upvote and a comment are also wonderful ways to provide feedback.

Professional Interests

• Technical Services and Consulting
• Embedded Systems | Firmware Developement | Simulations
• Electrical and Electronics Engineering

Feel free to contact me.

[Brian]

Thank you for your feedback and the process flow information. I believe Josh Kahn has answered the specifics of whether or not the MathWorks tools can do this.