Creating a new model in Simulink - Mechanics & Internals

Overview - Creating a new model

What is it?

Creating a new model in Simulink means building a visual diagram that represents a system or process. You use blocks to represent parts of the system and connect them with lines to show how data flows. This model helps simulate and analyze how the system behaves before building it in real life. It is like drawing a blueprint for a machine but with signals and logic.

Why it matters

Without creating a model, engineers and scientists would have to build and test physical systems blindly, which is costly and slow. Models let you test ideas quickly, find problems early, and improve designs safely. This saves time, money, and effort in real projects like cars, robots, or control systems.

Where it fits

Before creating a model, you should understand the basic Simulink interface and how to use blocks. After learning to create models, you will explore running simulations, analyzing results, and refining your designs. This is an early step in the journey of system simulation and control design.

Mental Model

Core Idea

Creating a new model in Simulink is like building a flowchart that visually shows how parts of a system connect and work together.

Think of it like...

Imagine building a LEGO set where each block is a part of a machine, and you snap them together to see how the machine works before turning it on.

┌───────────────┐
│ New Model     │
│  ┌─────────┐  │
│  │ Block A │──┼──▶ Output
│  └─────────┘  │
│       │       │
│  ┌─────────┐  │
│  │ Block B │  │
│  └─────────┘  │
└───────────────┘

Build-Up - 7 Steps

1

Foundation

Opening Simulink and Starting Model

Concept: Learn how to open Simulink and create a blank new model.

Open MATLAB, then click the Simulink icon or type 'simulink' in the command window. In Simulink, click 'Create Model' to open a blank canvas where you can build your system.

Result

A new empty model window opens, ready for you to add blocks.

Knowing how to start a new model is the first step to building any system simulation.

2

Foundation

Adding Basic Blocks to Model

Concept: Learn to add blocks like sources, sinks, and operations to the model.

From the Simulink Library Browser, drag blocks such as 'Constant' (source), 'Gain' (operation), and 'Scope' (sink) into your model window. These blocks represent inputs, processing, and outputs.

Result

Your model now has blocks representing parts of a system.

Blocks are the building pieces of your model, each with a specific role.

3

Intermediate

Connecting Blocks with Lines

🤔Before reading on: Do you think connecting blocks is automatic or do you have to draw lines yourself? Commit to your answer.

Concept: Learn how to connect blocks to show signal flow.

Click on the output port of one block and drag to the input port of another to create a line. This line shows how data moves from one block to the next.

Result

Blocks are linked, forming a path for signals to flow through the system.

Understanding connections is key to representing how parts of the system interact.

4

Intermediate

Saving and Naming Your Model

🤔Before reading on: Do you think saving a model is optional or necessary before simulation? Commit to your answer.

Concept: Learn to save your model with a meaningful name.

Click 'File' > 'Save As' and enter a name for your model file. This saves your work so you can open and modify it later.

Result

Your model is saved as a file on your computer.

Saving early prevents loss of work and helps organize multiple models.

5

Intermediate

Setting Model Parameters

Concept: Learn to configure basic model settings like simulation time.

Go to 'Simulation' > 'Model Configuration Parameters'. Set the 'Stop time' to control how long the simulation runs. This controls the time window your model simulates.

Result

Model is configured to simulate for the chosen duration.

Configuring parameters tailors the simulation to your system's needs.

6

Advanced

Using Subsystems to Organize Models

🤔Before reading on: Do you think subsystems are just visual or do they affect simulation? Commit to your answer.

Concept: Learn to group blocks into subsystems for clarity and reuse.

Select multiple blocks, right-click and choose 'Create Subsystem'. This groups them into one block that can be expanded or collapsed. Subsystems help manage complex models.

Result

Your model is cleaner and easier to understand with grouped blocks.

Using subsystems improves model readability and modular design.

7

Expert

Automating Model Creation with Scripts

🤔Before reading on: Can you create a Simulink model entirely by code? Commit to your answer.

Concept: Learn to create and configure models programmatically using MATLAB commands.

Use MATLAB commands like 'new_system', 'add_block', and 'add_line' to build models without the GUI. This is useful for generating many models or automating repetitive tasks.

Result

A Simulink model is created and connected by running a script.

Automating model creation saves time and reduces errors in large projects.

Under the Hood

Simulink models are stored as files describing blocks and their connections. When you run a simulation, Simulink translates this graphical model into executable code that calculates outputs step-by-step over time. Each block has mathematical or logical behavior defined internally, and signals flow along the lines connecting blocks.

Why designed this way?

Simulink was designed as a graphical tool to make system modeling intuitive and visual, lowering the barrier for engineers who think in block diagrams. The underlying code generation allows fast simulation and integration with MATLAB for analysis. This design balances ease of use with powerful simulation capabilities.

┌───────────────┐       ┌───────────────┐       ┌───────────────┐
│ Block A      │──────▶│ Block B      │──────▶│ Block C      │
│ (Function)  │       │ (Function)  │       │ (Function)  │
└───────────────┘       └───────────────┘       └───────────────┘
        │                      │                      │
        ▼                      ▼                      ▼
  Internal code           Internal code           Internal code
  executes block          executes block          executes block
  behavior                behavior                behavior

Myth Busters - 4 Common Misconceptions

Quick: Do you think you must write code to create a Simulink model? Commit yes or no.

Common Belief: Many believe Simulink models require coding to build.

Reality: Simulink models are primarily created by dragging and connecting blocks visually, with no code needed.

Why it matters: Believing code is required can discourage beginners from using Simulink's easy visual interface.

Quick: Do you think connecting blocks automatically runs the simulation? Commit yes or no.

Common Belief: Some think that once blocks are connected, the model simulates automatically.

Reality: You must explicitly start the simulation; connections only define the model structure.

Why it matters: Assuming automatic simulation can cause confusion when no results appear.

Quick: Do you think subsystems slow down simulation? Commit yes or no.

Common Belief: People often believe subsystems add overhead and slow simulations.

Reality: Subsystems are organizational tools and do not inherently slow down simulation; they can improve clarity and maintainability.

Why it matters: Avoiding subsystems due to this myth leads to messy, hard-to-manage models.

Quick: Do you think saving a model is optional before simulation? Commit yes or no.

Common Belief: Some think you can simulate without saving the model first.

Reality: Simulink requires the model to be saved before running simulation to manage files and results properly.

Why it matters: Not saving can cause errors or loss of work.

Expert Zone

1

Simulink models can be parameterized to run multiple simulations with different settings without changing the model structure.

2

Using masked subsystems allows hiding complexity and creating reusable components with user-friendly interfaces.

3

Model referencing enables breaking large systems into smaller models that can be developed and simulated independently.

When NOT to use

Simulink is less suitable for purely data-driven tasks or when you need very fast, low-level code; in those cases, direct MATLAB coding or other programming languages might be better.

Production Patterns

In industry, models are often developed incrementally, starting with simple blocks, then adding subsystems and parameterization. Automated scripts generate models for testing multiple scenarios. Models integrate with code generation tools to produce embedded software.

Connections

Flowcharts

Simulink models build on the same idea of visualizing processes step-by-step.

Understanding flowcharts helps grasp how Simulink shows system logic visually.

Software Engineering Modular Design

Subsystems in Simulink mirror modular programming concepts.

Knowing modular design helps appreciate how subsystems improve model clarity and reuse.

Electrical Circuit Diagrams

Both use symbols and connections to represent system components and flows.

Familiarity with circuit diagrams aids understanding of block connections and signal flow.

Common Pitfalls

#1 Trying to simulate without saving the model first.

Wrong approach:

sim('untitled')

Correct approach:

save_system('myModel'); sim('myModel')

Root cause:

Not understanding that Simulink requires a saved model file to run simulations.

#2 Connecting output port to output port instead of input port.

Wrong approach:

Dragging line from one block's output to another block's output.

Correct approach:

Dragging line from output port of one block to input port of another block.

Root cause:

Misunderstanding signal flow direction and port types.

#3 Adding too many blocks without grouping into subsystems.

Wrong approach:

Building large flat models with hundreds of blocks.

Correct approach:

Grouping related blocks into subsystems for clarity.

Root cause:

Not appreciating the importance of model organization and modularity.

Key Takeaways

Creating a new model in Simulink is a visual process of building a system from blocks connected by signal lines.

Starting with a blank model and adding blocks lets you represent inputs, operations, and outputs clearly.

Connecting blocks correctly defines how data flows through the system and affects simulation results.

Saving your model early and often protects your work and enables simulation.

Advanced techniques like subsystems and scripting help manage complexity and automate model creation.

Practice

1. What is the first step to create a new model in Simulink?

easy

A. Use new_system to create a new model.

B. Use simulink.open_system to open an existing model.

C. Add blocks directly without creating a model.

D. Save the model before creating it.

Solution

1. Step 1: Understand model creation functions

   The function new_system is used to create a new empty model in Simulink.

2. Step 2: Differentiate from opening models

   open_system opens existing models but does not create new ones.

3. Final Answer:

   Use new_system to create a new model. -> Option A

4. Quick Check:

   New model creation = new_system [OK]

Hint: Remember: new_system creates, open_system opens [OK]

Common Mistakes:

• Confusing new_system with open_system
• Trying to add blocks before creating a model
• Assuming saving creates a model

2. Which of the following is the correct syntax to create and open a new Simulink model named 'myModel'?

easy

A. simulink.create_system('myModel'); simulink.show_system('myModel');

B. simulink.open_system('myModel'); simulink.new_system('myModel');

C. new_system('myModel'); open_system('myModel');

D. simulink.new_system('myModel'); simulink.open_system('myModel');

Solution

1. Step 1: Identify correct function names

   The correct functions are new_system to create and open_system to open the model.

2. Step 2: Check function order and syntax

   Create the model first, then open it. new_system('myModel'); open_system('myModel'); follows this order and uses correct function names and syntax.

3. Final Answer:

   new_system('myModel'); open_system('myModel'); -> Option C

4. Quick Check:

   Create then open = new_system('myModel'); open_system('myModel'); [OK]

Hint: Create first, then open with correct function names [OK]

Common Mistakes:

• Using open_system before new_system
• Using incorrect function names like create_system
• Using incorrect 'simulink.' prefix

3. What will be the output of the following code snippet?

modelName = 'testModel';
new_system(modelName);
open_system(modelName);
blocks = find_system(modelName, 'Type', 'Block');
numBlocks = length(blocks);

What is the value of numBlocks right after running this code?

medium

A. 0

B. 1

C. An error occurs because the model is empty

D. Undefined variable error

Solution

1. Step 1: Understand model creation and block count

   After creating and opening a new model, it contains no blocks by default.

2. Step 2: Use find_system to count blocks

   find_system with 'Type'='Block' returns all blocks. Since none are added, the list is empty, so length is 0.

3. Final Answer:

   0 -> Option A

4. Quick Check:

   New model has zero blocks [OK]

Hint: New model starts empty, so block count is zero [OK]

Common Mistakes:

• Assuming default blocks exist
• Expecting an error for empty model
• Confusing blocks with system components

4. Consider this code snippet:

open_system('newModel');
new_system('newModel');

What is the main issue with this code when creating a new model?

medium

A. There is no issue; this code works fine.

B. The model is created twice, wasting memory.

C. The model name is invalid for Simulink.

D. The model is opened before it is created, causing an error.

Solution

1. Step 1: Analyze function order

   The code tries to open a model named 'newModel' before creating it, which causes an error because the model does not exist yet.

2. Step 2: Understand correct sequence

   The correct sequence is to create the model first with new_system, then open it.

3. Final Answer:

   The model is opened before it is created, causing an error. -> Option D

4. Quick Check:

   Open before create causes error [OK]

Hint: Always create before opening a model [OK]

Common Mistakes:

• Opening a model before creation
• Assuming open_system creates the model
• Ignoring error messages

5. You want to programmatically create a new Simulink model named 'controlSystem', add a Gain block, and open the model for editing. Which sequence of commands correctly achieves this?

hard

A. simulink.open_system('controlSystem'); add_block('simulink/Commonly Used Blocks/Gain', 'controlSystem/Gain1'); simulink.new_system('controlSystem');

B. new_system('controlSystem'); add_block('simulink/Commonly Used Blocks/Gain', 'controlSystem/Gain1'); open_system('controlSystem');

C. add_block('simulink/Commonly Used Blocks/Gain', 'controlSystem/Gain1'); simulink.new_system('controlSystem'); simulink.open_system('controlSystem');

D. simulink.new_system('controlSystem'); simulink.open_system('controlSystem'); add_block('simulink/Commonly Used Blocks/Gain', 'controlSystem/Gain1');

Solution

1. Step 1: Create the new model first

   Use new_system('controlSystem') to create the model before adding blocks.

2. Step 2: Add the Gain block to the model

   Use add_block with the correct source and destination path inside the new model.

3. Step 3: Open the model for editing

   Finally, open the model window with open_system('controlSystem') to see and edit it visually.

4. Final Answer:

   new_system('controlSystem'); add_block('simulink/Commonly Used Blocks/Gain', 'controlSystem/Gain1'); open_system('controlSystem'); -> Option B

5. Quick Check:

   Create, add block, then open model [OK]

Hint: Create model, add blocks, then open model [OK]

Common Mistakes:

• Adding blocks before creating the model
• Opening model before adding blocks
• Incorrect block path in add_block