Simulink. User's Guide

Description

Introduction to Simulink Simulink Basics Programmatic Modeling Basics Load a Model Create a Model and Specify Parameter Settings Programmatically Load Variables When Opening a Model Programmatically Add and Connect Blocks Programmatically Comment Out or Comment Through Blocks Name a Signal Programmatically Arrange Model Layouts Automatically Open the Same Model in Multiple Windows Use modelfinder to Index Simulink Models and Improve Their Discoverability Locate Diagram Elements Using Highlighting Specify Colors Programmatically Keyboard Shortcuts and Mouse Actions for Simulink Modeling View Keyboard Shortcuts in Editor Perform File and Clipboard Operations Zoom and Pan Navigate Model Select and Move Model Elements Add and Edit Model Elements Connect Model Elements Name Model Elements Format Block Diagram Perform Generic Actions Simulate, Update, and Generate Code for Models Open Models Open Simulink Open Blank Models Open Saved Models Load Model Variables and Data from MAT-File Automatically Initialize Variables and Load Data Set Default Template for New Models Set Favorite Files Clear Recent Files Open Model with Different Character Encoding Save Models Determine Whether a Model Has Unsaved Changes Save Models Choose Valid Model File Names Save Model Variables and Data Specify Code That Runs Before or After Saving Model Convert Model File Format to SLX Export Model to Previous Version of Simulink Add Blocks to Models Add Blocks to Models Using Quick Insert Menu Add Blocks to Models Using Library Browser Explore Available Blocks Using Library Browser Connect Blocks Connect Blocks With Signal Lines Connect Single Output Port to Multiple Input Ports Connect Output Ports of Multiple Blocks to Single Block Connect Subsystems Connect Blocks Without Signal Lines Comment Out and Comment Through Blocks Edit Block Parameters Edit Parameters on Block Icon Edit Parameters Using the Property Inspector Edit Parameters Using the Block Parameters Dialog Box Edit Parameters Programmatically Specify Block Parameters as Variables Configure Model Layout Improve Model Layout with Auto Arrange Move Multiple Model Elements Simultaneously Flip or Rotate Blocks Move Ports Group Blocks into Subsystems Create Subsystems Replace Subsystem with its Contents Specify Whether a Subsystem Is Atomic Determine Whether Subsystem Is Virtual Specify Subsystem Read/Write Permissions Save Subsystem as Separate File Configure Model Element Names and Labels Label Signal Lines Move Signal Line Labels Change Block Names Hide or Display Block Names Move Block Names Configure Model Style Elements Customize Model Colors Customize Model Fonts Copy Formatting Between Model Elements Increase Drop Shadow Depth Customize Block Icons Visually Organize Models Using Areas Annotate Models Create Text Annotations Add Equations to Text Annotations Add Symbols to Text Annotations Create Image Annotations Associate Annotations with Blocks and Areas Hide Annotations Add Hyperlinks to Annotations Navigate Model Hierarchy Enter and Exit Subsystems Enter and Exit Model References Navigate Model Hierarchy Tree Using Model Browser Bookmark Your Place in Models Create a Viewmark Open and Navigate Viewmarks Manage Viewmarks Save a Viewmark to the Model Refresh a Viewmark Search Model Contents Keyword Search for Model Elements and Parameters Search for Blocks Connected Without Signal Lines Keyword Search for Simulink Editor Actions Preview Content of Model Components Collaborate by Adding Comments to Blocks Determine Whether Model Has Open Comments View Comments Add Comments Edit, Reply to, and Resolve Comments Hide and Delete Comments Print Model Diagrams Print Models Using Default Settings Specify Paper Size and Orientation Specify Background Color Specify Print Frames Select the Systems to Print Print Large Diagrams on Multiple Pages Add Log of Printed Models Add Sample Time Legend Configure Print Job Print Models to PDFs Copy Diagrams as Images Print Model Reports Programmatically Print Models from MATLAB Command Window Printing Commands Print Systems with Multiline Names or Names with Spaces Set Paper Orientation and Type Position and Size a System Use Tiled Printing Print Models to Image File Formats Simulation Stepping Step Through Simulation Open and Configure Model Step Forward One Step at a Time Step Forward Multiple Time Steps at a Time Step Back in Simulation Finish or Stop Simulation How Stepping Through Simulation Works Stepping Forward Capturing Simulation Snapshots Stepping Back Pausing on Breakpoints Additional Considerations for Stepping Through Simulation Debug Simulation Using Signal Breakpoints Open and Configure Model Specify Time to Pause Simulation View Signal Values in Block Diagram Step Through Time Steps Set Breakpoint to Pause Simulation Step Block by Block View Execution Order End Simulation Debugging Session Simulation Pacing Use Simulation Pacing Use Simulation Pacing with Dashboard Blocks Limitations How Simulink Works Simulation Phases in Dynamic Systems Model Compilation Link Phase Simulation Loop Phase Compare Solvers Fixed-Step Versus Variable-Step Solvers Continuous Versus Discrete Solvers Explicit Versus Implicit Continuous Solvers One-Step Versus Multistep Continuous Solvers Single-Order Versus Variable-Order Continuous Solvers Zero-Crossing Detection Demonstrating Effects of Excessive Zero-Crossing Detection Preventing Excessive Zero Crossings How the Simulator Can Miss Zero-Crossing Events Zero-Crossing Detection in Blocks Zero-Crossing Detection with Fixed-Step Simulation Effects of Zero-Crossing Detection in Fixed-Step Simulate in Fixed-Step Without Zero-Crossing Detection Enable Fixed-Step Zero-Crossing Detection Set Parameters for Zero-Crossing Detection Zero-Crossing Algorithms Signal Threshold for Adaptive Zero-Crossing Detection Algebraic Loop Concepts Mathematical Interpretation Physical Interpretation Artificial Algebraic Loops How the Algebraic Loop Solver Works Implications of Algebraic Loops in a Model Identify Algebraic Loops in Your Model Highlight Algebraic Loops in the Model Use the Algebraic Loop Diagnostic Remove Algebraic Loops Remove Algebraic Loops by Introducing Delay Solve Algebraic Loops Manually How the Software Eliminates Artificial Algebraic Loops Eliminate Artificial Algebraic Loops Caused by Atomic Subsystems Bundled Signals That Create Artificial Algebraic Loops Model and Block Parameters to Diagnose and Eliminate Artificial Algebraic Loops Block Reduction and Artificial Algebraic Loops Modeling Considerations with Algebraic Loops Managing Large Models with Artificial Algebraic Loops Model Blocks and Direct Feedthrough Changing Block Priorities When Using Algebraic Loop Solver Use Model Name as Programmatic Interface Model Requirements Input Arguments Execute Size Computation Phase Execute Compilation Phase Compute Discrete State Values Compute Output Values Compute Continuous State Derivatives Execute Termination Phase Modeling Dynamic Systems Creating a Model Create Template from Model Edit a Template Describe Models Using Notes Create and Edit Annotations Programmatically Create Annotation Programmatically Programmatically Find and Modify Existing Annotations Delete Annotation Create Annotations That Contain Hyperlinks Add Image to Model Create Area Programmatically Create and Hide Markup Annotation Find Annotation Executing Callback Function Create Subsystems Types of Subsystems Create Subsystems Add Ports to Subsystems Edit Port Labels on Subsystems Configure Subsystems Restrict Subsystem Access Expand Subsystem Contents Why Expand a Subsystem? What Subsystems Can You Expand? Expand a Subsystem Results of Expanding a Subsystem Navigate Model Hierarchies Open Model Component in Current Tab Open Model Component in New Tab Open Model Component in New Window Open Referenced Model as Top Model in New Window Subsystem Reference Create a Subsystem Block Diagram Reference a Subsystem File in a Model Convert an Existing Subsystem to a Referenced Subsystem Edit and Save Referenced Subsystem Attach Data Dictionary to Subsystem Reference Add a System Mask for Subsystem Reference Create Self-Modifiable Subsystem Reference Using System Mask Simulate a Subsystem Block Diagram with a Test Harness Subsystem Reference Compatibility with Previous Versions Control Referenced Subsystem Programmatically Best Practices Reference a Subsystem File in a Model Change Subsystem Reference Component Dynamically Using InitFcn Validate Subsystem Reference Use and Build Model Using Component Codes Index for Subsystem Reference Examples Use Control Flow Logic What is a Control Flow Subsystem Equivalent C Language Statements Conditional Control Flow Logic While and For Loops Customize Model Behavior with Callbacks What You Can Do with Callbacks Types of Callbacks Callback Limitations Model Callbacks Create Model Callbacks Model Callback Parameters Referenced Model Callbacks Block Callbacks Block Opening Callback Parameters Block Editing Callback Parameters Block Compilation and Simulation Callback Parameters Block Saving and Closing Callback Parameters Subsystem Block Callback Parameters Port Callbacks Initialization Function Model InitFcn Callback Block InitFcn Callback Manage Model Versions and Specify Model Properties Model File Change Notification Manage Model Properties Access Model Information Programmatically Model Discretizer What Is the Model Discretizer? Requirements Discretize a Model with the Model Discretizer View the Discretized Model Discretize Blocks from the Simulink Model Discretize a Model with the sldiscmdl Function Create Model That Performs Neighborhood Processing Import Image and Output Results Configure Neighborhood Processing Subsystem Simulate and View Results Specify Region of Interest for Neighborhood Processing Import Image and Output Results Configure Neighborhood Processing Subsystem Simulate and View Results Use Neighborhood Processing Subsystem Block Padding Options with Region of Interest Overview of Parameters Example Model Advisor Check Your Model Using the Model Advisor Model Advisor Overview Run Model Advisor Checks and Review Results Run Model Checks Programmatically Find Model Advisor Check IDs Address Model Check Results Fix a Model Advisor Check Warning or Failure Save and View Model Advisor Check Reports Save Model Advisor Check Reports View Model Advisor Check Reports Upgrade Advisor Consult the Upgrade Advisor Upgrade Programmatically Upgrade Advisor Checks Working with Sample Times What Is Sample Time? What Is Union Sample Time? Specify Sample Time Designate Sample Times Specify Block-Based Sample Times Interactively Specify Port-Based Sample Times Interactively Specify Block-Based Sample Times Programmatically Specify Port-Based Sample Times Programmatically Access Sample Time Information Programmatically Specify Sample Times for a Custom Block Determining Sample Time Units Change the Sample Time After Simulation Start Time View Sample Time Information Inspect Sample Time Using Timing Legend Inspect Sample Times Throughout a Model Types of Sample Time Discrete Sample Time Continuous Sample Time Inherited Sample Time Fixed-in-Minor-Step Constant Sample Time Variable Sample Time Controllable Sample Time Triggered Sample Time Asynchronous Sample Time Blocks for Which Sample Time Is Not Recommended Best Practice to Model Sample Times Appropriate Blocks for the Sample Time Parameter Specify Sample Time in Blocks Where Hidden Block Compiled Sample Time Sample Times in Subsystems Sample Times in Systems Purely Discrete Systems Hybrid Systems Resolve Rate Transitions Automatic Rate Transition Visualize Inserted Rate Transition Blocks How Propagation Affects Inherited Sample Times Process for Sample Time Propagation Simulink Rules for Assigning Sample Times Backpropagation in Sample Times Specify Execution Domain Domain Specification Badge Types of Execution Domains Set Execution Domain Enforce Discrete Execution Domain for a Subsystem Referencing a Model Model Reference Basics Model Reference Advantages Model Hierarchies Model Block and Referenced Model Interface Model Workspaces and Data Dictionaries Referenced Model Execution Referenced Model Simulation and Code Generation Model Reference Requirements and Limitations Model Reuse Model Masks S-Functions in Referenced Models Model Architecture Requirements and Limitations Signal Requirements and Limitations Simulation Requirements and Limitations Code Generation Requirements and Limitations Reference Existing Models Reference Protected Models from Third Parties Load Supporting Files for Protected Model Verify Digital Signature of Protected Model View Protected Model Contents Test Protected Model in Isolated Environment Reference Protected Model Use Models Protected in Previous Releases Convert Subsystems to Referenced Models Prepare Subsystem for Conversion Convert Subsystems to Referenced Models Conversion Results Compare Simulation Results Before and After Conversion Revert Conversion Integrate Referenced Model into Parent Model Conditionally Execute Referenced Models Conditional Models Requirements for Conditional Models Modify a Referenced Model for Conditional Execution Inspect Model Hierarchies Content Preview Model Dependency Graph List of Model References Model Version Numbers Model Reference Interface and Boundary Refresh Model Blocks Signal Propagation Signal Logging in Referenced Models Sample Time Requirements Share Data Among Referenced Model Instances Referenced Model Sample Times How Sample-Time Inheritance Works for Model Blocks Conditions for Inheriting Sample Times Determining Sample Time of a Referenced Model Blocks That Depend on Absolute Time Blocks Whose Outputs Depend on Inherited Sample Time Sample Time Consistency Sample Rates and Solvers Choose Simulation Modes for Model Hierarchies Model Reference Simulation Modes Overridden Simulation Modes Simulate Conditionally Executed Referenced Models Triggered, Enabled, and Triggered and Enabled Models Function-Call Models Simulate Multiple Referenced Model Instances in Normal Mode Normal Mode Visibility Examine Models with Multiple Referenced Model Instances Configure Models with Multiple Referenced Model Instances Determine Which Instance Has Normal Mode Visibility Specify the Instance Having Normal Mode Visibility Manage Simulation Targets for Referenced Models Reduce Time Spent Checking For Changes Specify Programming Language of Simulation Targets Use Custom Code for Simulation Targets Control Location of Simulation Targets Reduce Update Time for Referenced Models by Using Parallel Builds Share Simulink Cache Files for Faster Simulation Inspect Simulink Cache File Contents Use Simulink Cache Files Check for Simulink Cache Files in Projects Set Configuration Parameters for Model Hierarchies Manage Configuration Parameters by Using Configuration References Configuration Requirements for All Referenced Model Simulation Diagnostics That Are Ignored in Accelerator Mode Parameterize Instances of a Reusable Referenced Model Specify a Different Value for Each Instance of a Reusable Model Define Model Arguments Without Specifying a Default Value Combine Multiple Arguments into a Structure Parameterize a Referenced Model Change Model Argument Name or Value Customize User Interface for Reusable Components Configure Instance-Specific Data for Simulink.LookupTable and Simulink.Breakpoint Objects Parameterize a Referenced Model Programmatically Group Multiple Model Arguments into a Single Structure Configure Instance-Specific Data for Lookup Tables Programmatically Simulink Units Unit Specification in Simulink Models Guidelines for Unitless, Dimensionless, and No Unit Quantities Specify Physical Quantities Specify Units in Objects Specify Units for Temperature Signals Specify Units in MATLAB Function Blocks Specify Units in Constant Blocks Specify Units for Logging and Loading Signal Data Restricting Unit Systems Displaying Units Unit Consistency Checking and Propagation Unit Propagation Between Simulink and Simscape Converting Units Automatic Unit Conversion Limitations Update an Existing Model to Use Units Model for Updating Units Incrementally Work Through the Model to Set Units Working with Custom Unit Databases Custom Units Spreadsheet Format Define Custom Units in Excel Spreadsheet Create and Load Custom Unit Database Troubleshooting Units Undefined Units Overflow and Underflow Errors or Warning Mismatched Units Detected Mismatched Units Detected While Loading Disallowed Unit Systems Automatic Unit Conversions Unsuccessful Automatic Unit Conversions Simscape Unit Specification Incompatible with Simulink Conditional Subsystems Conditionally Executed Subsystems Overview Ensure Output Port Is Virtual Merged Conditional Output Signals Merged Partial-Write Signals Using Enabled Subsystems Create an Enabled Subsystem Blocks in Enabled Subsystems Alternately Executing Enabled Subsystem Blocks Model Examples Using Triggered Subsystems Create a Triggered Subsystem Triggering with Discrete Time Systems Triggered Model Versus a Triggered Subsystem Blocks in a Triggered Subsystem Model Examples Using Enabled and Triggered Subsystems Creating an Enabled and Triggered Subsystem Blocks in an Enabled and Triggered Subsystem Model Examples Select Subsystem Execution Models with If-Else Structures Models with Switch Case Structure Iterate Subsystem Execution with While Iterator and For Iterator Subsystems Models with While Structures Model with For Structures Repeat an Algorithm Using a For-Each Subsystem Explore Example Model Reduce Signal Line Density with Buses Repeat an Algorithm Organize Parameters into Arrays of Structures Inspect Converted Model Additional Examples of Working with For-Each Subsystems Limitations of For-Each Subsystems Using Function-Call Subsystems Creating a Function-Call Subsystem Sample Time Propagation in a Function-Call Subsystem Latched Input Data for Function-Call Subsystems Conditional Subsystem Initial Output Values Inherit Initial Output Values from Input Signals Specify Initial Output Values Using Dialog Parameters Schedule Components to Avoid Data Dependency Issues Create Rate-Based Model Rate-Based Model with Scheduled Subsystem Blocks Test Rate-Based Model Simulation Using Function-Call Generators Create Test Model That References Rate-Based Model Simulate Test Harness for Rate-Based Model Avoid Common Compile and Run-Time Errors Generate Code from Rate-Based Model Code Generation Report for Rate-Based Models Generated Code Entry Points for Rate-Based Models Sorting Rules for Explicitly Scheduled Model Components Export-Function Models Test Harness for Export Function Models with Strict Scheduling Test Harness for Export-Function Models Without Strict Scheduling Data Dependency Error Caused by Data Sorting Rules Test Harness for Models with Initialize, Reset, and Terminate Function Blocks Initiators for Model Block in Test Harness Conditional Subsystem Output Values When Disabled Simplified Initialization Mode When to Use Simplified Initialization Set Initialization Mode to Simplified Classic Initialization Mode Set Initialization Mode to Classic Classic Initialization Issues and Limitations Identity Transformation Can Change Model Behavior Inconsistent Output with Discrete-Time Integrator or S-Function Block Execution Order Affecting Merge Block Output Tunable Parameters State Simulink does not provide correct consistency check Convert from Classic to Simplified Initialization Mode Blocks to Consider Create Export-Function Model Designate Model as Export-Function Model and Satisfy Export-Function Model Requirements Create Model Algorithms Add Function-Call Inputs Export-Function Model with Unit Delay and Square Functions Test Model Test Export-Function Model Simulation Using Input Matrix Create Function-Call Inputs and Data Inputs Simulate Export-Function Model Test Export-Function Model Simulation Using Function-Call Generators Reference an Export-Function Model Create Test Model (Harness) for Simulation Prepare Export-Function Model for Simulation Test Export-Function Model with Function-Call Generator Blocks Test Export-Function Model Simulation Using Stateflow Chart Reference an Export-Function Model Create Periodic Scheduler Using Stateflow Chart Create Test Model (Harness) for Simulation Prepare Export-Function Model for Simulation Test Export-Function Model Using Stateflow Chart Test Export-Function Model Simulation Using Schedule Editor Create Test Model (Harness) for Simulation Create Function-Call Events Using the Schedule Editor Prepare Export-Function Model for Simulation Test Export-Function Model Using Schedule Editor Generate Code for Export-Function Model Generate Code for Exported Functions Generate Code for Export-Function Model with Rate-Based Model Create Export-Function Model with Scheduled Subsystems and Rate-Based Model Generate Code for Export-Function Model with Rate-Based Model Export-Function Models Overview Workflows for Export-Function Models Blocks Allowed at Top Level of Export-Function Models Requirements for Export-Function Models Designating an Export-Function Model Sample Time for Function-Call Subsystems Execution Order for Root-Level Function-Call Inport Blocks Nested Export-Function Models Export-Function Model with a Multi-Instanced Function-Call Model Export-Function Models and Models with Asynchronous Function-Call Inputs Using Resettable Subsystems Behavior of Resettable Subsystems Comparison of Resettable Subsystems and Enabled Subsystems Model Examples Simulink Functions Overview What Are Simulink Functions? What Are Simulink Function Callers? Connect to Local Signals Reusable Logic with Functions Input/Output Argument Behavior Shared Resources with Functions How a Function Caller Identifies a Function Reasons to Use a Simulink Function Block Choose a Simulink Function or Reusable Subsystem When Not to Use a Simulink Function Block Tracing Simulink Functions Highlight and Animate Function Calls Add a Simulink Function to a Model Simulink Functions and Function Callers Create Simulink Function Using Simulink Function Block Create Simulink Function Using Exported Graphical Function from Stateflow Chart Create Simulink Function Using Exported MATLAB Function from Stateflow Chart Call a Simulink Function from a Model Simulink Functions and Function Callers Use a Function Caller Block to Call a Simulink Function Block Use a MATLAB Function Block to Call a Simulink Function Block Use a Stateflow Chart to Call a Simulink Function Block Call a Simulink Function Block from Multiple Sites Argument Specification for Simulink Function Blocks Example Argument Specifications for Data Types Input Argument Specification for Bus Data Type Input Argument Specification for Enumerated Data Type Input Argument Specification for an Alias Data Type Simulink Function Blocks in Referenced Models Simulink Function Block in Referenced Model Function Caller Block in Referenced Model Function and Function Caller Blocks in Separate Referenced Models Function and Function Caller in Same Model Scoped, Global, and Port-Scoped Simulink Function Blocks Overview Scoped Simulink Function Blocks in Subsystems Resolve to a Function Hierarchically Resolve to a Function by Qualification Scoped Simulink Function Blocks in Models Resolve to a Function Hierarchically Resolve to a Function by Qualification Multi-Instance Modeling with Simulink Functions Call Simulink Functions in Other Models Using Function Ports Connect Client and Server Models with Function Ports Configure Asynchronous Interfaces with Function Ports Diagnostics Using a Client-Server Architecture Diagnostic Messaging with Simulink Functions Client-Server Architecture Modifier Pattern Observer Pattern Using Initialize, Reinitialize, Reset, and Terminate Functions Create Model Component with State Initialize Block State Reset Block State Read and Save Block State Prepare Model Component for Testing Create an Export-Function Model Create Test Harness to Generate Function Calls Reference the Export-Function Model Model an Event Scheduler Connect Chart to Test Model Initialize and Reset Parameter Values Adding a Parameter Writer Block Writing to Tunable Block Parameters Writing to Model Instance Parameters Writing to Masked Subsystem Parameters Writing to Model Workspace Variables Initialize, Reinitialize, Reset, and Terminate Function Limitations Unsupported Blocks and Signals Unsupported Modeling Patterns Reinitialize States of Blocks in Subsystem Model House Heating System Open Completed House System Model Define a House Heating System Model House Heating System Integrate a House Heating Model Prepare for Simulation Run and Evaluate Simulation Wireless Tire Pressure Monitoring System with Fault Logging Prepare Sensor and Controller Models in a Distributed Monitoring System for Code Generation Fixed-Point Data Type Support for If Block Floating-Point Model without Fixed-Point Data Block and Model Configurations Model with If Action Subsystems and Fixed-Point Data Types Model Analysis Messages in Simulink Simulink Messages Overview Model Message Send and Receive Interfaces and Generate Code Model Event-Driven Receive Interfaces Simulate Middleware Effects on a Distributed Architecture Animate and Understand Sending and Receiving Messages Use a Queue Block to Manage Messages Establish Message Send and Receive Interfaces Between Software Components Connect Message Receive Interface with Simulink Functions Modeling Message Communication Patterns with SimEvents Build a Shared Communication Channel with Multiple Senders and Receivers Model Wireless Message Communication with Packet Loss and Channel Failure Model an Ethernet Communication Network with CSMA/CD Protocol Send and Receive Messages Carrying Bus Data Use Virtual Buses with Message Elements for Component Communication Merge Message Lines Using a Message Merge Block Specify Queue Properties for Message Interface Specify Queue Properties Queue Expansion Virtual Buses with Message Elements in Architecture Models Use the Sequence Viewer to Visualize Messages, Events, and Entities Components of the Sequence Viewer Window Navigate the Lifeline Hierarchy View State Activity and Transitions View Function Calls Simulation Time in the Sequence Viewer Window Redisplay of Information in the Sequence Viewer Window Using Message Polling and Message Triggered Subsystems Asynchronous Message Handling in Adaptive Cruise Control Temperature Control System Communicating with Messages Modeling Variant Systems What Are Variants and When to Use Them What Are Variants? Advantages of Using Variants When to Use Variants Types of Variants in Simulink Variant Blocks in Simulink Use Variants to Create One Model for Many Systems Working with Variants Variant Terminology Command Line Parameters Working with Variant Choices Default Variant Choice Active Variant Choice Inactive Variant Choice Empty Variant Choice List of Variant Choices Open Active Variant Introduction to Variant Controls Variant Control Modes in Variant Blocks Types of Variant Control Modes in Variant Blocks Switch Between Choices Using Condition Expressions in Variant Blocks Switch Between Choices Using Labels in Variant Blocks Switch Between Choices for Simulation and Code Generation Workflows Without Using Control Variables in Variant Blocks Compare Different Types of Variant Control Modes in Variant Blocks Variant Activation Times for Different Variant Control Modes in Variant Blocks Use Variant Control Variables in Variant Blocks Simulink.VariantControl Variables for Coherent Switching of Choices in Variant Blocks Scalar Variant Control Variables for Rapid Prototyping in Variant Blocks Simulink.Parameter Type of Variant Control Variables for Code Generation in Variant Blocks Enumerated Types To Improve Code Readability of Variant Control Variables of Variant Blocks Simulink.Variant Objects for Variant Condition Reuse of Variant Blocks Structures to Group Related Variant Control Variables of Variant Blocks Activate Variant During Different Stages of Simulation and Code Generation Workflow Stages to Set Active Choices in Variant Blocks and Variant Parameters Types of Variant Activation Time in Variant Blocks and Variant Parameters Variant Activation Time for Variant Blocks Variant Activation Time in Variant Parameters Storage Classes for Different Variant Activation Times Create a Simple Variant Model Create Variant Controls Programmatically Create and Export Variant Controls Reuse Variant Conditions Enumerated Types as Variant Controls Prepare Variant-Containing Model for Code Generation Convert Variant Control Variables into Simulink.Parameter Objects Configure Model for Generating Preprocessor Conditionals Visualize Variant Implementations in a Single Layer How Variant Sources and Sinks Work Advantages of Using Variant Sources and Sinks Limitations of Using Variant Sources and Sinks Define and Configure Variant Sources and Sinks Represent Variant Choices in Variant Source and Variant Sink Blocks Variant Condition Propagation with Variant Sources and Sinks How Variant Condition Propagation Works Condition Propagation with Subsystems Condition Propagation with Other Simulink Blocks Limitations Propagate Variant Conditions Outside Variant Subsystems Factors That Affect Propagation of Variant Conditions Adaptive Interface for Variant Subsystems Propagation with Different Activation Times Propagation Without Inport and Outport Blocks Propagate Conditions Programmatically Limitations Use Variant Subsystem Blocks with Conditionally Executed Subsystems Create a Variant Subsystem with Enabled Subsystem as Choice Use Variant Subsystem Block to Create an Export-Function Model Propagate Variant Conditions from Variant Subsystem Blocks to Conditional Subsystems Limitations Convert Configurable Subsystem to Variant Subsystem Convert Configurable Subsystem Blocks to Variant Subsystem Blocks Using Upgrade Advisor Programmatically Convert Configurable Subsystem Blocks to Variant Subsystem Blocks Using Upgrade Advisor Convert Configurable Subsystem Blocks to Variant Subsystem Blocks Programmatically Using convertToVariant Convert Configurable Subsystem Blocks to Variant Subsystem Blocks Through the Dialog Changing Active Variant Variant Elements Within Buses Create Buses with Variant Conditions Variant Condition Propagation with Bus Code Generation Virtual and Nonvirtual Bus Behavior Variant Bus with Model Block Known Limitations V-Model for System Development with Simulink Variants System-Level Model Components — Create Models with Structural Variations Components — Create Models with Parameter Value Variations Components — Create Models with Variations in Transition Paths Components — Create Models with Variations in Dimensions Components — Create Models with Variations in AUTOSAR Interfaces Components — Manage Structural Variations in a Model Generated Code Component Tests and System-Level Tests Approaches to Control Active Variant Choice of a Variant Block Using Mask or Model Workspace Control Active Choice of Locked Custom Library Variant Subsystem Using Mask Parameter Model Switch Between Active Choices Propagate Variant Conditions from Variant Source Blocks to Subsystem Blocks Implement Variations in Separate Hierarchy Using Variant Subsystems Variant Source and Variant Sink Blocks Control Variant Condition Propagation Propagate Variant Conditions from Variant Source Blocks to Conditionally Executed Subsystems Use Variant Source Block to Control Execution of Conditional Subsystem Blocks Hierarchical Nesting of Variant Sources and Variant Sinks Export-Function model with Variant Subsystem Variant Subsystem with Enable Subsystem as Choice Automatic Mask Icon Promotion in Variant Subsystems Create Variant Controls Using an In-Memory Enumeration Class Create Variant Controls Using MATLAB Enumeration Class Provide Variation at Source and Destination of a Signal Using Manual Variant Source and Manual Variant Sink Blocks Simulink Variant Examples Use Variant Source Block to Receive or Output Function-Call Signals for Simulation and Code Generation Variant Function-Call Signals on Variant Subsystem Outport Verify and Validate Variant Models with Code Compile Activation Time Identify Variant Activeness of a Block After Model Compilation Considerations and Limitations for startup Variant Activation Time Combining startup and code compile Variant Activation Times in Variant Conditions Use of Variant Control Variables with startup Variant Activation Time in Another Variant Block Run Iterative Simulations Without Recompiling Model for Variant Systems Using Fast Restart Generate Code from an Export Function Model Variant Condition Propagation Overview Automatically Identify Variant Regions Using Variant Condition Propagation Visualize Propagated Variant Conditions Using Variant Conditions Legend Condition Propagation Scenarios Simulate Variant Subsystem with Startup Activation Using parsim Known Limitations of startup variant activation time Simulate a Protected Model with Code Compile or Startup Activation Time Verify and Validate Variant Models with Startup Activation Time Simulate Variant Blocks in Accelerator and Rapid Accelerator Modes with Startup Activation Time Generate Code from Variant Blocks with Startup Activation Time Create Standalone Executables with Variants Using Simulink Compiler Generate Code from Nested Variant Subsystem with Code Compile and Startup Activation Create Real-Time Applications Using Variants and Simulink Real-Time Use find_system with Built-In MatchFilter Options for Variant Blocks Export and Import Function Mockup Unit (FMU) from Model with Variant Subsystem Blocks Add or Remove Variant Choices of Variant Assembly Subsystem Blocks Using External Files Manipulate Variant Choices of Variant Assembly Subsystem Block in Label Mode Manipulate Variant Choices of Variant Assembly Subsystem Block in Expression Mode Convert Variant Subsystem to Variant Assembly Subsystem Convert Variant Subsystem Block with Expressions to Variant Assembly Subsystem Block Interactively Convert Variant Subsystem Block with Expressions to Variant Assembly Subsystem Block Programmatically Convert Variant Subsystem Block with Labels to Variant Assembly Subsystem Block Interactively Convert Variant Subsystem Block with Labels to Variant Assembly Subsystem Block Programmatically Control Variant Choices in Masked Variant Assembly Subsystem Block Using Mask Parameter Object Switch Between Variant Choices of Masked Variant Assembly Subsystem Block in Label Mode Switch Between Variant Choices of Masked Variant Assembly Subsystem Block in Expression Mode Represent Variant Condition Values of Enumerated Type in Generated Code Managing Model Configurations Set Model Configuration Parameters for a Model Set Configuration Parameters Programmatically Set Configuration Parameters by Using the Dialog Box Manage Configuration Sets for a Model Create a Configuration Set in a Model Change Configuration Parameter Values in a Configuration Set Activate a Configuration Set Copy, Delete, and Move a Configuration Set Save a Configuration Set Load a Saved Configuration Set Compare Configuration Sets Share a Configuration with Multiple Models Create a Configuration Set in the Data Dictionary Create and Attach a Configuration Reference Resolve a Configuration Reference Activate a Configuration Reference Create a Configuration Reference in Another Model Change Parameter Values in a Referenced Configuration Set Change Parameter Value in a Configuration Reference Save a Referenced Configuration Set Load a Saved Referenced Configuration Set Configuration Reference Limitations Share a Configuration Across Referenced Models Automate Model Configuration by Using a Script Configuration Object Functions Configuring Models for Targets with Multicore Processors Concepts in Multicore Programming Basics of Multicore Programming Types of Parallelism System Partitioning for Parallelism Challenges in Multicore Programming Multicore Programming with Simulink Basic Workflow How Simulink Helps You to Overcome Challenges in Multicore Programming Implement Data Parallelism in Simulink Implement Task Parallelism in Simulink Implement Pipelining in Simulink Configure Your Model for Concurrent Execution Specify a Target Architecture Choose from Predefined Architectures Define a Custom Architecture File Partition Your Model Using Explicit Partitioning Prerequisites for Explicit Partitioning Add Periodic Triggers and Tasks Add Aperiodic Triggers and Tasks Map Blocks to Tasks, Triggers, and Nodes Implicit and Explicit Partitioning of Models Partitioning Guidelines Configure Data Transfer Settings Between Concurrent Tasks Optimize and Deploy on a Multicore Target Generate Code Build on Desktop Profile and Evaluate Explicitly Partitioned Models on a Desktop Customize the Generated C Code Programmatic Interface for Concurrent Execution Map Blocks to Tasks Supported Targets For Multicore Programming Supported Multicore Targets Supported Heterogeneous Targets Limitations with Multicore Programming in Simulink Multithreaded Simulation Using For Each Subsystem Modeling Best Practices General Considerations when Building Simulink Models Avoiding Invalid Loops Shadowed Files Model Building Tips Model a Continuous System Best-Form Mathematical Models Series RLC Example Solving Series RLC Using Resistor Voltage Solving Series RLC Using Inductor Voltage Model a Simple Equation Model Differential Algebraic Equations Overview of Robertson Reaction Example Simulink Models from ODE and DAE Equations Simulink Model from ODE Equations Simulink Model from DAE Equations Simulink Model from DAE Equations Using Algebraic Constraint Block Basic Modeling Workflow Model a System Algorithm Create Model Components Manage Signal Lines Manage Model Data Reuse Model Components from Files Create Interchangeable Variations of Model Components Set Up a File Management System Project Setup Organize Large Modeling Projects What Are Projects? Explore Project Tools with the Airframe Project Explore the Airframe Project Set Up Project Files and Open the Project View, Search, and Sort Project Files Open and Run Frequently Used Files Review Changes in Modified Files Run Dependency Analysis Run Project Integrity Checks Commit Modified Files View Project and Source Control Information Create a Project from a Model Set MATLAB Projects Preferences Create a New Project from a Folder Add Files to the Project Create a New Project from an Archived Project Create a New Project Using Templates Use Project Templates from R2014a or Before Open Recent Projects Specify Project Details, Startup Folder, and Derived Files Folders Specify Project Path What Can You Do with Project Shortcuts? Automate Startup Tasks Automate Shutdown Tasks Create Shortcuts to Frequent Tasks Create Shortcuts Group Shortcuts Annotate Shortcuts to Use Meaningful Names Customize Shortcut Icons Use Shortcuts to Find and Run Frequent Tasks Create Templates for Standard Project Settings Using Templates to Create Standard Project Settings Create a Template from the Current Project Create a Template from a Project Under Version Control Edit a Template Remove a Template Explore the Example Templates Project File Management Group and Sort File Views Search Inside Project Files and Filter File Views Project-Wide Search Filter Project File Views More Ways to Search Work with Project Files Manage Shadowed and Dirty Models and Other Project Files Identify Shadowed Project Files When Opening a Project Find Models and Other Project Files With Unsaved Changes Manage Open Models and Data Dictionaries When Closing a Project Move, Rename, Copy, or Delete Project Files Move or Add Files Automatic Updates When Renaming, Deleting, or Removing Files Back Out Changes Create Labels Add Labels to Files View and Edit Label Data Automate Project Tasks Using Scripts Create a Custom Task Function Run a Project Custom Task and Publish Report Sharing Projects Share Project by Email Share Project as a MATLAB Toolbox Share Project on GitHub Archive Projects Upgrade All Project Models, Libraries, and MATLAB Code Files Upgrade Libraries Analyze Model Dependencies Open and Explore Dependency Graph Model Dependency Views Find Required Products Export Dependency Analysis Results Create Project from the Dependency Graph View Requirements Toolbox Links Associated with Model Elements Highlight, Filter, and View Information for Links in a Model Navigate to Externally Stored Requirements from a Model Project Dependency Analysis Dependency Analyzer Scope and Limitations Analysis Scope Analysis Limitations Run a Dependency Analysis Explore the Dependency Graph, Views, and Filters Select, Pan, and Zoom Investigate Dependency Between Two Files Color Files by Type, Status, or Label Apply and Clear Filters Perform an Impact Analysis About Impact Analysis Run a Dependency Analysis Find Required Products and Add-Ons Find Dependencies of Selected Files Check Dependency Results and Resolve Problems Investigate Problem Files in Dependency Graph Investigate Problem Files in File List Find Requirements Documents in a Project Export Dependency Analysis Results Send Files to Project Tools Project Source Control About Source Control with Projects Classic and Distributed Source Control Add a Project to Source Control Add a Project to Git Source Control Add a Project to SVN Source Control Set Source Control Preferences Set Git Preferences in MATLAB Online Register Model Files with Source Control Tools Set Up SVN Source Control Set Up SVN Provided with Projects Set Up Project SVN for SVN Version Already Installed Set Up Project SVN for SVN Version Not Yet Provided with Projects Register Model Files with Subversion Enforce SVN Locking Model Files Before Editing Share a Subversion Repository Manage SVN Externals Set Up Git Source Control Register Binary Files with Git Configure MATLAB for Git on Windows Configure MATLAB to Use Git SSH Authentication Install Git Credential Helper Disable Compression for Simulink Models Configure Git to Use Git LFS Configure Git to use MATLAB for Diff and Merge Install Command-Line Git Client Add Git Submodules Update Submodules Use Fetch and Merge with Submodules Use Push to Send Changes to the Submodule Repository Automatically Merge Models Create New GitHub Repository Disable Source Control Change Source Control Write a Source Control Integration with the SDK Clone Git Repository Check Out SVN Repository Tag and Retrieve Versions of Project Files Refresh Status of Project Files Check for Modifications Update Revisions of Project Files Update Revisions with SVN Update Revisions with Git Update Selected Files Get SVN File Locks Manage SVN Repository Locks View Modified Files Project Definition Files Compare Revisions Run Project Checks Commit Modified Files to Source Control Revert Changes Discard Local Changes Revert a File to a Specified Revision Revert the Project to a Specified Revision Pull, Push, and Fetch Files with Git Pull and Push Pull, Fetch, and Merge Push Empty Folders Use Git Stashes Branch and Merge Files with Git Create a Branch Switch Branch Compare Branches and Save Copies Merge Branches Revert to Head Delete Branches Resolve Conflicts Resolve Conflicts Merge Text Files Merge Models Extract Conflict Markers Work with Derived Files in Projects Customize External Source Control to Use MATLAB for Diff and Merge Finding the Full Paths for MATLAB Diff, Merge, and AutoMerge Integration with Git Integration with SVN Integration with Other Source Control Tools Continuous Integration Using MATLAB Projects and Jenkins Prerequisites Set Up MATLAB Project for Continuous Integration in Jenkins Reduce Test Runtime Using Dependency Cache and Impact Analysis Enhance Workflow Determine Order for Resolving Conflicts Using Dependency Analyzer Project Reference Componentization Using Referenced Projects Add or Remove a Reference to Another Project View, Edit, or Run Referenced Project Files Extract a Folder to Create a Referenced Project Manage Referenced Project Changes Using Checkpoints Compare Simulink Models About Simulink Model Comparison Creating Model Comparison Reports Examples of Model Comparison Using Model Comparison Reports Select Simulink Models to Compare Compare Simulink Models Navigate the Simulink Model Comparison Report Step Through Changes Explore Changes in the Original Models Merge Differences Open Child Comparison Reports for Selected Nodes Understand the Report Hierarchy and Matching Filter Comparison Reports Change Color Preferences Save Comparison Results Examples of Model Comparison Limitations Display Differences in Original Models Highlighting in Models Control Highlighting in Models View Changes in Model Configuration Parameters Merge Simulink Models from the Comparison Report Resolve Conflicts Using Three-Way Model Merge Use Three-Way Merge with External Source Control Tools Open Three-Way Merge Without Using Source Control Two-Way Model Merge Merge MATLAB Function Block Code Export, Print, and Save Model Comparison Results Save Printable Report Export Results to the Workspace Comparing Models with Identical Names Work with Referenced Models and Library Links Compare Project or Model Templates Compare Project Templates Compare Model Templates Simulink Model Comparison for GitHub Pull Requests Prerequisites Attach Diff Reports Using GitHub Actions Design Evolution Management About Design Evolutions Evolutions and Evolution Trees Manage Evolutions and Evolution Trees Create Evolution Tree Create Evolution Update Evolution Get Evolution into Project Delete Evolutions Inspect Properties of Evolutions and Compare Evolutions Inspect Properties of Evolution Tree, Evolutions, and Connectors Compare Evolutions Use Design Evolution Manager with the Fixed-Point Tool Use Design Evolution Manager with Fixed-Point Tool Large-Scale Modeling Component-Based Modeling Guidelines Should You Create Model Components? Define Model Components Choose Among Types of Model Components Simulink Components High-Level Component Selection Guidelines Modeling Requirement Considerations Compare Capabilities of Model Components Development Process Performance Requirements Features Define Interfaces of Model Components Identify Component Boundaries Simplify Interfaces with Buses Partition Interface Data Configure Data Interfaces Configuration Management Manage Designs Using Source Control Determine the Files Used by a Component Manage Model Versions Create Configurations Power Window Example Power Window Study Power Windows MathWorks Software Used in This Example Quantitative Requirements Simulink Power Window Controller Project Simulink Power Window Controller Create Model Using Model-Based Design Automatic Code Generation for Control Subsystem References Schedule Editor What are Partitions? Create Partitions Partitioning a Model Create Partitions from a Rate-Based Model Export-Function Partitions Using the Schedule Editor Using the Schedule Editor Schedule the Partitions Schedule an Export-Function Model Using the Schedule Editor Schedule a Rate-Based Model Using the Schedule Editor Generate Code from a Partitioned Model Export-Function Conversion Create and Analyze Random Schedules for a Model Using the Schedule Editor API Events in Schedule Editor Event Management in the Schedule Editor Schedule Partitions with Events Test Harness Generation Limitations and Error Conditions Software Modeling Software Component Modeling Create Models of Software Components Create Model of Target Environment Test System by Simulating Composition Model Integrate Components into Software Architectures Design Software Architectures Generate Code for Software Components Simulating Dynamic Systems Running Simulations Simulate a Model Interactively Simulation Basics Run, Pause, and Stop a Simulation Use Blocks to Stop or Pause a Simulation Use Local Solvers in Referenced Models How Local Solvers Work How to Configure Local Solvers Additional Considerations for Local Solvers Choose a Solver Solver Selection Criteria Choose a Jacobian Method for an Implicit Solver Sparsity of Jacobian Solver Jacobian Methods Heuristic 'auto' Method Full and Sparse Perturbation Methods Full and Sparse Analytical Methods Code Generation Support Variable Step Solvers in Simulink Variable-Step Discrete Solver Variable-Step Continuous Solvers Variable-Step Continuous Explicit Solvers Variable-Step Continuous Implicit Solvers Error Tolerances for Variable-Step Solvers Fixed Step Solvers in Simulink Fixed-Step Discrete Solver Fixed-Step Continuous Solvers Choose a Fixed-Step Solver When to Use a Fixed-Step Solver Establish Baseline Results Using a Variable-Step Solver Run Fixed-Step Simulations of the Model Compare Fixed-Step Simulations with the Variable-Step Baseline Select Solver Using Auto Solver Use Model Operating Point for Faster Simulation Workflow Benefits of Using Operating Point Save an Operating Point Restore Operating Point Operating Point Behavior Change the States of a Block Within Operating Point S-Functions Model Changes and Operating Point Restore Limitations of Saving and Restoring Operating Point Specify Initial State for Simulation View Diagnostics Toolbar Diagnostic Message Pane Trace Diagnostics Location Identify Diagnostics from Custom Compilers Suppress Diagnostics Suggested Actions Systematic Diagnosis of Errors and Warnings Suppress Diagnostic Messages Programmatically Suppress Diagnostic Messages Programmatically Suppress Diagnostic Messages of a Referenced Model Customize Diagnostic Messages Display Custom Text Create Hyperlinks to Files, Folders, or Blocks Create Programmatic Hyperlinks Report Diagnostic Messages Programmatically Create Diagnostic Stages Report Diagnostic Messages Log Diagnostic Messages View and Trace Callbacks in Models Filters Stage-Specific Callbacks Search Export Trace Callbacks Programmatically Running a Simulation Programmatically Run Simulations Programmatically sim Command Simulations Run-Button Simulations Run Parallel Simulations How parsim works Using sim Function Within parfor Overview of Calling sim from Within parfor Error Handling in Simulink Using MSLException Error Reporting in a Simulink Application The MSLException Class Methods of the MSLException Class Capturing Information About the Error Multiple Simulations Running Multiple Simulations Multiple Simulations with Simulink Editor Multiple Simulations with Parallel Computing Toolbox Multiple Simulations with the sim Function Multiple Simulations with Simulink.SimulationInput Object Simulation Manager to Monitor Simulations The parsim/batchsim Function Capabilities Data Logging for Multiple Simulations Run Parallel Simulations for a Thermal Model of a House Using parsim Run Multiple Parallel Simulations with Different Set Points View the Runs in the Simulation Manager Comparison Between Multiple Simulation Workflows parsim Workflow batchsim Workflow Analyze Results Using Simulation Manager Open Simulation Manager Add and Configure Plots Save and Load Simulation Manager Configure and Run Simulations with Multiple Simulations Panel Workflow for Multiple Simulations Panel Multiple Simulations Panel: Simulate for Different Values of Stiffness for a Vehicle Dynamics System Visualizing and Comparing Simulation Results Prototype and Debug Models with Scopes Scope Blocks and Scope Viewer Overview Overview of Methods Simulink Scope Versus Floating Scope Simulink Scope Versus DSP System Toolbox Time Scope Scope Trace Selection Panel Scope Triggers Panel What Is the Trigger Panel Main Pane Source/Type and Levels/Timing Panes Hysteresis of Trigger Signals Delay/Holdoff Pane Cursor Measurements Panel Scope Signal Statistics Panel Scope Bilevel Measurements Panel Bilevel Measurements Settings Transitions Pane Overshoots / Undershoots Pane Cycles Pane Peak Finder Measurements Panel Spectrum Analyzer Cursor Measurements Panel Spectrum Analyzer Channel Measurements Panel Spectrum Analyzer Distortion Measurements Panel Spectral Masks Set Up Spectral Masks Check Spectral Masks Spectrum Analyzer CCDF Measurements Panel Common Scope Block Tasks Connect Multiple Signals to a Scope Save Simulation Data Using Scope Block Pause Display While Running Copy Scope Image Plot an Array of Signals Scopes in Referenced Models Scopes Within an Enabled Subsystem Modify x-axis of Scope Show Signal Units on a Scope Display Select Number of Displays and Layout Dock and Undock Scope Window to MATLAB Desktop View Values of Parameters Set as Variables In-Place Parameter Value Display for Different Data Types In-Place Parameter Value Display for Variables Defined in Multiple Workspaces Turn Off In-Place Parameter Value Display Floating Scope and Scope Viewer Tasks Add Floating Scope Block to Model and Connect Signals Add Scope Viewer to a Signal Add Signals to an Existing Floating Scope or Scope Viewer Save Simulation Data from Floating Scope Add and Manage Viewers Quickly Switch Visualization of Different Signals on a Floating Scope Generate Signals Without Source Blocks Attach Signal Generator Modify Signal Generator Parameters Remove Signal Generator Viewers and Generators Manager Open the Viewers and Generators Manager Change Parameters Connect Viewers and Generators View Test Point Data Customize Viewers and Generators Manager Limitations Control Scope Blocks Programmatically Plot a Circle Using the XY Graph Block Sample Time with Scope Blocks Inspecting and Comparing Simulation Data View Data in the Simulation Data Inspector View Logged Data Import Data from the Workspace or a File View Complex Data View String Data View Frame-Based Data View Event-Based Data Import Workspace Variables Using a Custom Data Reader Import Data Using a Custom File Reader View and Replay Map Data Visualize Simulation Data on an XY Plot Analyze Data Using the XY Plot View Many Signals Together Using Sparklines View Multidimensional Signals Using the Array Plot Microsoft Excel Import, Export, and Logging Format Basic File Format Multiple Time Vectors Signal Metadata User-Defined Data Types Complex, Multidimensional, and Bus Signals Function-Call Signals Simulation Parameters Multiple Runs Import Data from a CSV File into the Simulation Data Inspector Basic File Format Multiple Time Vectors Signal Metadata Import Data from a CSV File Configure the Simulation Data Inspector Logged Data Size and Location Archive Behavior and Run Limit Incoming Run Names and Location Signal Metadata to Display Signal Selection on the Inspect Pane How Signals Are Aligned for Comparison Colors Used to Display Comparison Results Signal Grouping Data to Stream from Parallel Simulations Options for Saving and Loading Session Files Signal Display Units View Streaming Data in the Simulation Data Inspector Open and Simulate the Model Change Time Span Control Plot Update Behavior Freeze Display Control Display Scaling and Display Offset Control Display of Streaming Data Using Triggers Examine the Model Interactively Generate Trigger Events Capture Signal Transient Response Stabilize a Steady-State Periodic Signal Synchronize Cursors in the Simulation Data Inspector with an App Designer App Open and Run the Cursors App Examine the App Code Iterate Model Design Using the Simulation Data Inspector View and Inspect Signals During Simulation Automatically Transfer View to Current Simulation Control Data Retention Visualize Many Logged Signals Access Data in a MATLAB Function During Simulation Write a Callback Function for Data Access Configure Signals for Data Access Analyze Multidimensional Signal Data Convert Representation of Multidimensional Data Plot Multidimensional Signal Data Compare Multidimensional Signals Convert Representation of Frame-Based Data Analyze Data from Multiple Simulations Open and Simulate the Model Create and Save Views to Analyze Simulation Results Load a View and Plot Signals Side by Side Swap Source Run for Plotted Signals Save and Share Simulation Data Inspector Data and Views Save and Load Simulation Data Inspector Sessions Share Simulation Data Inspector Views Share Simulation Data Inspector Plots Create Simulation Data Inspector Report Export Data to the Workspace or a File Export Video Signal to an MP4 File Create Interactive Comparison Reports Create Plots Using the Simulation Data Inspector Add Visualizations Select Plot Layout View Simulation Data Using Time Plot Add Text to Plot Layout Add Subplots to Visualize Data Customize Time Plot Appearance Customize Signal Appearance Shade Signal Regions Rename Signals Inspect Simulation Data Configure Signals for Logging View Signals View Signals on Multiple Plots Zoom, Pan, and Resize Plots Inspect Simulation Data Using Cursors Replay Data Inspect Metadata Modify Signal Properties in the Simulation Data Inspector Modify Signal Units Modify Signal Data Type Modify Signal Names Replay Data in the Simulation Data Inspector Compare Simulation Data Setup Compare Signals Compare Runs Configure Comparison Constraints Cancel Comparisons How the Simulation Data Inspector Compares Data Signal Alignment Synchronization Interpolation Tolerance Specification Limitations Inspect and Compare Data Programmatically Create a Run and View the Data Compare Two Signals in the Same Run Compare Runs with Global Tolerance Analyze Simulation Data Using Signal Tolerances Keyboard Shortcuts for the Simulation Data Inspector General Actions Plot Zooming Data Cursors Signal Table Import Dialog Box Control Simulations with Interactive Displays Tune and Visualize Your Model with Dashboard Blocks Explore Connections Within the Model Simulate Changing Model States View Signal Data Tune Parameters During Simulation Getting Started with Panels Open Example Model Create Panels Populate and Edit Panels Manage Panel Visibility Use Panels to Monitor Signals and Control Parameters Open Example Model Create Panels Simulate Model Create Tabbed Panels Open Example Model Create Panels Add Empty Tab to Panel Detach Tab from Panel Attach Tab or Freestanding Panel to Another Panel Reorder Panel Tabs Design Custom Gauges Design Custom Knobs Design Custom Lamps Design Custom Rocker, Slider, and Toggle Switches Design Custom Buttons Design Custom Rotary Switches Design Custom Sliders Analyzing Simulation Results Decide How to Visualize Simulation Data Simulation Data Inspector Scope Blocks and the Scope Viewer Record Block Dashboard Blocks Port Value Displays Custom MATLAB Visualizations Linearizing Models Improving Simulation Performance and Accuracy How Optimization Techniques Improve Performance and Accuracy Speed Up Simulation How Profiler Captures Performance Data How Profiler Works Start Profiler Save Profiler Results Check and Improve Simulation Accuracy Check Simulation Accuracy Unstable Simulation Results Inaccurate Simulation Results Modeling Techniques That Improve Performance Accelerate the Initialization Phase Reduce Model Interactivity Reduce Model Complexity Choose and Configure a Solver Save the Model Operating Point Use Performance Advisor to Improve Simulation Efficiency Understanding Total Time and Self Time in Profiler Reports Performance Advisor Improve Simulation Performance Using Performance Advisor Performance Advisor Workflow Prepare Your Model Create a Performance Advisor Baseline Measurement Run Performance Advisor Checks View and Respond to Results View and Save Performance Advisor Reports Perform a Quick Scan Diagnosis Run Quick Scan on a Model Checks in Quick Scan Mode Improve vdp Model Performance Enable Data Logging for the Model Create Baseline Select Checks and Run Review Results Apply Advice and Validate Manually Use Hardware Acceleration to Speed Up Simulation for Object Detection Solver Profiler Examine Model Dynamics Using Solver Profiler Zero-Crossing Events Solver Exception Events Tolerance-Exceeding Events Newton Iteration Failures Infinite State and Infinite Derivative Exceptions Differential Algebraic Equation Failures Solver Resets Zero-Crossing Discrete Signal ZOH Signal Block Signal Initial Reset Internal Jacobian Logging and Analysis Modify Solver Profiler Rules Change Thresholds of Profiler Rules Develop Profiler Rule Set Customize State Ranking Solver Profiler Interface Toolstrip Statistics Pane Suggestions Pane Debug Simulations Simulink Debugging Programmatic Interface Use Simulink Debugging Functions Use MATLAB Functions Understand Block and Method IDs Set and Manage Breakpoints Display Information About the Simulation Display Information About the Model Debug Simulation of Iterator Subsystem Open Example Model Add Port Value Labels Set Breakpoint to Pause Within Time Step Step Through Block Execution Step into While-Iterator Subsystem Pause on Specific Iteration View Execution Order End Simulation Debugging Session Accelerating Models What Is Acceleration? How Acceleration Modes Work Overview Normal Mode Accelerator Mode Rapid Accelerator Mode Code Regeneration in Accelerated Models Determine If the Simulation Will Rebuild Parameter Tuning in Rapid Accelerator Mode Choosing a Simulation Mode Simulation Mode Tradeoffs Comparing Modes Decision Tree Design Your Model for Effective Acceleration Select Blocks for Accelerator Mode Select Blocks for Rapid Accelerator Mode Control S-Function Execution Accelerator and Rapid Accelerator Mode Data Type Considerations Behavior of Scopes and Viewers with Rapid Accelerator Mode Factors Inhibiting Acceleration Perform Acceleration Customize the Build Process Run Acceleration Mode from the User Interface Making Run-Time Changes Switching Solvers between Runs Interact with the Acceleration Modes Programmatically Why Interact Programmatically? Build JIT Accelerated Execution Engine Control Simulation Simulate Your Model Customize the Acceleration Build Process Comparing Performance Performance When Target Must Be Rebuilt Performance When Targets Are Up to Date Analyze Performance of Simulation Modes How to Improve Performance in Acceleration Modes Techniques C Compilers Managing Blocks Working with Blocks Nonvirtual and Virtual Blocks Specify Block Properties Set Block Annotation Properties Specify Block Callbacks Specify Block Execution Priority and Tag Use Block Description to Identify a Block Create Block Annotations Programmatically Display Port Values for Debugging Display Port Values for Easy Debugging Display Value for a Specific Port Display Port Values for a Model Port Value Label Limitations Control and Display Execution Order Execution Order Viewer Navigation from Blocks to Tasks Execution Order Notation Determining Execution Order Check for Execution Order Changes Involving Data Store Memory Blocks Access Block Data During Simulation About Block Run-Time Objects Access a Run-Time Object Listen for Method Execution Events Synchronizing Run-Time Objects and Simulink Execution Working with Block Parameters Set Block Parameter Values Programmatically Access Parameter Values Specify Parameter Values Considerations for Other Modeling Goals Share and Reuse Block Parameter Values by Creating Variables Reuse Parameter Values in Multiple Blocks and Models Define a System Constant Set Variable Value by Using a Mathematical Expression Control Scope of Parameter Values Permanently Store Workspace Variables Manage and Edit Workspace Variables Package Shared Breakpoint and Table Data for Lookup Tables Parameter Interfaces for Reusable Components Referenced Models Subsystems Organize Related Block Parameter Definitions in Structures Create and Use Parameter Structure Store Data Type Information in Field Values Control Field Data Types and Characteristics by Creating Parameter Object Manage Structure Variables Define Parameter Hierarchy by Creating Nested Structures Group Multiple Parameter Structures into an Array Create a Structure of Constant-Valued Signals Considerations Before Migrating to Parameter Structures Combine Existing Parameter Objects Into a Structure Parameter Structures in the Generated Code Parameter Structure Limitations Package Shared Breakpoint and Table Data for Lookup Tables Create Parameter Structure According to Structure Type from Existing C Code Tune and Experiment with Block Parameter Values Iteratively Adjust Block Parameter Value Between Simulation Runs Tune Block Parameter Value During Simulation Prepare for Parameter Tuning and Experimentation Interactively Tune Using Dashboard Blocks Which Block Parameters Are Tunable During Simulation? Why Did the Simulation Output Stay the Same? Tunability Considerations and Limitations for Other Modeling Goals Optimize, Estimate, and Sweep Block Parameter Values Sweep Parameter Value and Inspect Simulation Results Store Sweep Values in Simulink.SimulationInput Objects Capture and Visualize Simulation Results Improve Simulation Speed Sweep Parameter Values to Test and Verify System Estimate and Calibrate Model Parameters Tune and Optimize PID and Controller Parameters Control Block Parameter Data Types Reduce Maintenance Effort with Data Type Inheritance Techniques to Explicitly Specify Parameter Data Types Use the Model Data Editor for Batch Editing Calculate Best-Precision Fixed-Point Scaling for Tunable Block Parameters Detect Numerical Accuracy Issues Due to Quantization and Overflow Reuse Custom C Data Types for Parameter Data Data Types of Mathematical Expressions Block Parameter Data Types in the Generated Code Specify Minimum and Maximum Values for Block Parameters Specify Parameter Value Ranges Restrict Allowed Values for Block Parameters Specify Range Information for Tunable Fixed-Point Parameters Unexpected Errors or Warnings for Data with Greater Precision or Range than double Optimize Generated Code Switch Between Sets of Parameter Values During Simulation and Code Execution Working with Lookup Tables About Lookup Table Blocks Anatomy of a Lookup Table Guidelines for Choosing a Lookup Table Data Set Dimensionality Data Set Numeric and Data Types Data Accuracy and Smoothness Dynamics of Table Inputs Efficiency of Performance Summary of Lookup Table Block Features Breakpoint and Table Size Features in Lookup Tables Tunable Size Symbolic Dimensions Reusable Struct Data Types for Different Breakpoint and Table Array Sizes Characteristics of Lookup Table Data Sizes of Breakpoint Vectors and Table Data Monotonicity of Breakpoints Formulation of Evenly Spaced Breakpoints Methods for Approximating Function Values About Approximating Function Values Interpolation Methods Extrapolation Methods Rounding Methods Example Output for Lookup Methods Use the Lookup Table Editor Start the Lookup Table Editor Edit Lookup Tables Lookup Table Editor Limitations Edit Lookup Table Data with Lookup Table Spreadsheet Lookup Table Spreadsheet Data Type Support Create Simulink.LookupTable Objects How to Open the Simulink.LookupTable Object Property Dialog Box Create Table and Breakpoint Data View Multidimensional Slices of Data Edit Table and Breakpoint Data with MATLAB Expressions Edit Table and Breakpoint Data Enable Heatmap for Table Data Overflow Handling Data Validation Lookup Table Spreadsheet Tabular Interface Shortcuts Enter Breakpoints and Table Data Enter Data in Block Parameter Dialog Box Enter Data in Lookup Table Editor Enter Data for Multiple Lookup Tables in Lookup Table Editor Enter Data Using Inports of Lookup Table Dynamic Block Import Lookup Table Data from MATLAB Import Standard Format Lookup Table Data Propagate Standard Format Lookup Table Data Import Nonstandard Format Lookup Table Data Propagate Nonstandard Format Lookup Table Data Copy and Paste Lookup Table Data from Excel Import Lookup Table Data from Excel Using readtable Visualize Data Through Plots Generate Report of Lookup Table Register Custom Lookup Table Blocks Visualize Lookup Tables Visualized Through Lookup Table Control Create a Logarithm Lookup Table Prelookup and Interpolation Blocks Optimize Generated Code for Lookup Table Blocks Remove Code That Checks for Out-of-Range Inputs Optimize Breakpoint Spacing in Lookup Tables Reduce Data Copies for Lookup Table Blocks Efficient Code for Row-Major Array Layout Row-Major Algorithm in Existing Models Containing Lookup Table Blocks Update Lookup Table Blocks to New Versions Comparison of Blocks with Current Versions Compatibility of Models with Older Versions of Lookup Table Blocks How to Update Your Model What to Expect from the Model Advisor Check Working with Block Masks Masking Fundamentals Masking Terminology Create a Simple Mask Manage Existing Masks Change a Block Mask View Mask Parameters Look Under Block Mask Remove Mask Mask Callback Code Add Mask Code Execute Drawing Command Execute Initialization Command Execute Callback Code Draw Mask Icon Using Mask Drawing Commands Draw Static Icon Draw Dynamic Icon Initialize Mask Dialog Variables Initialization Code Mask Initialization Best Practices Promote Block Parameters on a Mask Control Masks Programmatically Pass Values to Blocks Under the Mask Parameter Promotion Mask Initialization Referencing Block Parameters Using Variable Names Mask Linked Blocks Guidelines for Mask Parameters Mask Behavior for Masked, Linked Blocks Mask a Linked Block Dynamic Mask Dialog Box Show Parameter Enable Parameter Create Dynamic Mask Dialog Box Set Up Nested Masked Block Parameters Dynamic Masked Subsystem Allow Library Block to Modify Its Contents Create Self-Modifying Masks for Library Blocks Debug Masks That Use MATLAB Code Code Written in Mask Editor Code Written Using MATLAB Editor/Debugger Introduction to System Mask Create and Reference a Masked Model Step 1: Define Mask Arguments Step 2: Create Model Mask Step 3: View System Mask Parameters Step 4: Reference Masked Model Control System Mask Programmatically Handling Large Number of Mask Parameters Customize Tables for Masked Blocks Adding a Custom Table Parameter Control Custom Table Programmatically Add Images in Masks Store Mask Images Programmatically Create Hierarchical List in Mask Dialog Validating Mask Parameters Using Constraints Create and Associate a Constraint Create a Cross-Parameter Constraint Rule Attributes Custom Constraint for Mask Parameter Share Parameter Constraints Across Multiple Block Masks Control Constraints Programmatically Define Measurement Units for Masked Blocks Masking Example Models Create a Custom Table in the Mask Dialog Create a Block Mask Icon Mask a Variant Subsystem Tune Mask Popup Parameters by Referencing an External Enumeration File Visualize and Plot N-Dimensional Data Using Mask Lookup Table Control Validate Input and Output Port Signals Using Port Constraints Create and Edit Masked Block Icon Using Graphical Icon Editor Edit the Properties of Block Mask Icon and Its Elements Add Dynamic Behavior to Masked Icons Create Block Mask Icon Validate Port Signals Among Ports of the Same Masked Block Draw Mask Icon Using Drawing Commands Mask Display and Initialization Commands MATLAB Graphics in Masking Unsafe Mask Callback Error Organize Mask Initialization and Callbacks in a MATLAB File Creating Custom Blocks Types of Custom Blocks MATLAB Function Blocks MATLAB System Blocks Subsystem Blocks C Caller Block C Function Block S-Function Blocks Masked Blocks Comparison of Custom Block Functionality Model State Behavior Simulation Performance Code Generation Multiple Input and Output Ports Speed of Updating the Simulink Diagram Callback Methods Comparing MATLAB S-Functions to MATLAB Functions for Code Generation Expanding Custom Block Functionality Design and Create a Custom Block Setup Working Environment to Design and Create a Custom Block How to Design a Custom Block Defining Custom Block Behavior Deciding on a Custom Block Type Placing Custom Blocks in a Library Adding a User Interface to a Custom Block Adding Block Functionality Using Block Callbacks Integrate Python GPS Text Message Parsing Algorithms in Simulink Working with Block Libraries Create Custom Library Data Dictionary for Custom Libraries Blocks for Custom Libraries Annotations in Custom Libraries Lock and Unlock Libraries Prevent Disabling of Library Links Add Libraries to Library Browser Add Library to Library Browser Add Sublibrary to Library Browser Specify Library Order in Library List Linked Blocks Rules for Linked Blocks Linked Block Terminology Parameterized Links and Self-Modifiable Linked Subsystems Parameterized Links Self-Modifiable Linked Subsystems Create a Self-Modifiable Library Block Display Library Links Disable or Break Links to Library Blocks Break Links Lock Links to Blocks in a Library Rules for Locked Links Restore Disabled Links Restore Disabled Links Individually Restore Disabled Links Hierarchically Restore Parameterized Links Fix Unresolved Library Links Install Missing Product Resolve Path to Source Block Specify Unresolved Block Details for Custom Libraries Control Linked Block Programmatically Linked Block Information Lock Linked Blocks Link Status Maintain Compatibility of Library Blocks Using Forwarding Tables Forwarding Table Entry for a Renamed Block Move Block from One Library to Another Add or Remove Parameters from the Block Split Block Functionality Create Mask Parameter Aliases Integrating Custom C/C++ Code Debug Custom C/C++ Code In-Process and Out-of-Process Simulation Integrate C Code in Simulink Models Integrate C Code Using C Caller Blocks Specify Source Code and Dependencies N-D Array Handling Call C Caller Block and Specify Ports Map C Function Arguments to Simulink Ports Create a FunctionPortSpecification Object and Edit C Caller Block Properties Create a Custom C Caller Library Debug Custom Code Generate Code from Model Limitations Use C Caller Block with Conditional Execution Integrate Algorithms Using C Function Blocks Integrate External C/C++ Code into Simulink Using C Function Blocks Write External Source Files Enter the External Code Into Simulink Specify Simulation or Code Generation Code Specify Declaration for Target-Specific Function for Code Generation Interface with C++ Classes Using C Function Block Create Source Code Files Configure the C Function Block Limitations Modify States of a C Function Block Using Persistent Symbols Change Values of Signals Using C Function Block and Buses Access Elements of a Matrix Using Output Code in a C Function Block Use External Functions with Matrix Input in a C Function Block Define an Alias Type in a C Function Block Use Enumerated Data in a C Function Block Use Inherited Sizes in a C Function Block Call a Legacy Lookup Table Function Using C Caller block Start and Terminate Actions Within a C Function Block Call C++ Class Methods Using a C-style Wrapper Function from a C Function Block Call C++ Class Methods Directly from a C Function Block Call Legacy Lookup Table Functions Using C Function Block Use C Function Block Within For Each Subsystem Simulink Code Importer Import Custom Code Using the Simulink Code Importer Wizard Using the MATLAB Function Block Implement MATLAB Functions in Simulink with MATLAB Function Blocks Calculate Mean and Standard Deviation with a MATLAB Function Block Program the MATLAB Function Block Check Properties for MATLAB Function Block Variables Build the Function Prepare the Block for Code Generation Configure MATLAB Function Blocks Programmatically Call MATLAB Function Objects Programmatically Configure Block Properties Access Block Inputs, Outputs, and Properties Programmatically Access MATLAB Function Reports Code Generation Readiness Tool Issues Tab Files Tab Check Code Using the Code Generation Readiness Tool Run Code Generation Readiness Tool at the Command Line Run the Code Generation Readiness Tool From the Current Folder Browser Debug MATLAB Function Blocks Debug an Example Function Set Conditions on Breakpoints Watch Function Variables During Simulation Check for Data Range Violations Debug MATLAB Function Blocks in Initialize Function and Terminate Function Blocks Prevent Algebraic Loop Errors in MATLAB Function, Chart, and Truth Table Blocks Manage Function Call Outputs of a MATLAB Function Block Create Function Call Outputs Enable a Function-Call Subsystem with a MATLAB Function Block Considerations When Triggering Function-Call Subsystems Set Function Call Output Properties Manage the Input Trigger of a MATLAB Function Block Create an Input Trigger Enable a MATLAB Function Block with an Input Trigger Set Input Trigger Properties Create and Define MATLAB Function Block Variables Create and Delete MATLAB Function Block Variables Set General Variable Properties Set Limit Range Properties Set Description Properties Specify MATLAB Function Block Properties MATLAB Function Block Properties Fixed-Point Properties Description and Document Link Properties Programmatically Specify Block Properties MATLAB Function Reports Open a MATLAB Function Report Analyze MATLAB Source Code View Error and Warning Messages View MATLAB Variables Report Limitations Define and Modify Variable Data Types Specify Variable Data Types Inheriting Data Types Built-In Data Types Fixed-Point Designer Data Type Properties Specify Data Types with Expressions Specify Size of MATLAB Function Block Variables Inherit Size from Simulink Customize Variable Sizes Configure MATLAB Function Block Parameter Variables Control Parameter Variables with Masks Control Parameter Variables in Workspaces Resolve Signal Objects for Output Variables Implicit Signal Resolution Eliminating Warnings for Implicit Signal Resolution in the Model Disabling Implicit Signal Resolution for a MATLAB Function Block Forcing Explicit Signal Resolution for an Output Signal Types of Structures in MATLAB Function Blocks Attach Bus Signals to MATLAB Function Blocks Structures in a MATLAB Function Block Structure Definitions in Example Bus Objects Define Structure Inputs and Outputs Write Buses From Data Store Memory to a MATLAB Function Block How Structure Inputs and Outputs Interface with Bus Signals Working with Virtual and Nonvirtual Buses Rules for Defining Structures in MATLAB Function Blocks Index Substructures and Fields Create Structures in MATLAB Function Blocks Use Nonvirtual Buses with MATLAB Function Blocks Assign Values to Structures and Fields Initialize Matrix Using a Nontunable Structure Parameter Define and Use Structure Parameters Defining Structure Parameters FIMATH Properties of Nontunable Structure Parameters Limitations of Structures and Buses in MATLAB Function Blocks Declare Variable-Size MATLAB Function Block Variables Output Variables Other Scope Types Use a Variable-Size Signal in a Filtering Algorithm Control Memory Allocation for Variable-Size Arrays in a MATLAB Function Block Provide Upper Bounds for Variable-Size Arrays Disable Dynamic Memory Allocation for MATLAB Function Blocks Modify the Dynamic Memory Allocation Threshold Use Dynamic Memory Allocation for Variable-Size Arrays in a MATLAB Function Block Create Model Configure Model for Dynamic Memory Allocation Simulate Model Using Dynamic Memory Allocation Use Dynamic Memory Allocation for Bounded Arrays Generate C Code That Uses Dynamic Memory Allocation Code Generation for Enumerations Define Enumerations for MATLAB Function Blocks Allowed Operations on Enumerations MATLAB Toolbox Functions That Support Enumerations Add Enumerated Inputs, Outputs, and Parameters to a MATLAB Function Block Enumerations in a MATLAB Function Block Use Global Data in MATLAB Function Blocks Use Global Data from Data Store Memory Blocks Use Global Data from Simulink.Signal Objects Choose How to Store Global Data Retrieve Data From Data Store Memory Blocks Retrieve Data From Simulink.Signal Objects Example Using Data Store Diagnostics to Detect Memory Access Issues Initialize Persistent Variables in MATLAB Functions MATLAB Function Block with No Direct Feedthrough State Control Block in Synchronous Mode Stateflow Chart Implementing Moore Semantics Run Simulations and Generate Code with Masked Library Subsystems Containing MATLAB Function Blocks Include MATLAB Code as Comments in Generated Code How to Include MATLAB Code as Comments in the Generated Code Location of Comments in Generated Code Including MATLAB user comments in Generated Code Limitations of MATLAB Source Code as Comments Integrate C Code by Using the MATLAB Function Block Call C Code from a Simulink Model Use coder.ceval in an Example MATLAB Function Block Control Imported Bus and Enumeration Type Definitions Control Run-Time Checks Types of Run-Time Checks When to Disable Run-Time Checks How to Disable Run-Time Checks Call MATLAB Function Files in MATLAB Function Blocks Interface with Row-Major Data in MATLAB Function Block Row-Major Layout in Simulation and Code Generation Array Layout Conversions Array Layout and Algorithmic Efficiency Row-Major Layout for N-Dimensional Arrays Specify Array Layout in External Function Calls Code and Integration Limitations for MATLAB Function Blocks Use Supported Functions Prepare Variables for Code Generation Use Nondirect Feedthrough in a MATLAB Function Block System Objects in Simulink MATLAB System Block Why Use the MATLAB System Block? Choosing the Right Block Type System Objects Interpreted Execution or Code Generation Default Input Signal Attributes MATLAB System Block Limitations MATLAB System and System Objects Examples Implement a MATLAB System Block Understanding the MATLAB System Block Change Blocks Implemented with System Objects Call Simulink Functions from MATLAB System Block Create a Simulink Function Block Create a MATLAB System Block and Define System Object Call a Simulink Function in a Subsystem from a MATLAB System Block Call Simulink Functions from a MATLAB System Block Specify Sample Time for MATLAB System Block Types of Sample Time for MATLAB System Block Change Block Icon and Port Labels Modify MATLAB System Block Dialog Change the MATLAB System Block Icon to an Image Nonvirtual Buses and MATLAB System Block Use System Objects in Feedback Loops Simulation Modes Interpreted Execution vs. Code Generation Simulation Using Code Generation Mapping System Object Code to MATLAB System Block Dialog Box System Object to Block Dialog Box Default Mapping System Object to Block Dialog Box Custom Mapping Considerations for Using System Objects in Simulink Variable-Size Signals Tunable Parameters System Objects as Properties Default Property Values System Objects in For Each Subsystems Input Validation Simulink Engine Interaction with System Object Methods Simulink Engine Phases Mapped to System Object Methods Add and Implement Propagation Methods When to Use Propagation Methods Implement Propagation Methods Share Data with Other Blocks Setup Working Environment to Share System Object Data with Other Blocks Data Sharing with the MATLAB System Block Choose How to Store Shared Data How to Use Data Store Memory Blocks for the MATLAB System Block How to Set Up Simulink.Signal Objects Using Data Store Diagnostics to Detect Memory Access Issues Limitations of Using Shared Data in MATLAB System Blocks Use Shared Data with P-Coded System Objects Troubleshoot System Objects in Simulink Class Not Found Error Invoking Object Method Performance Customize MATLAB System Block Dialog Break Algebraic Loops Customize MATLAB System Block Appearance Implement a Simple Algorithm Specify Output Characteristics of MATLAB System Block Customize System Block Appearance Specify Input and Output Names Add Text to Block Icon Add Image to Block Icon Customize System Object Dialog Box Using Mask Editor Build System Object Dialog Box Using Mask Editor Customize System Block Dialog Box Using System object Define Block Dialog Tabs, Sections, and Order of Properties Define Property Sections Add Header Description Control Simulation Type in MATLAB System Block Add Custom Button to MATLAB System Block Specify Output Set Output Size Set Fixed- or Variable-Size Output Set Output Data Type Set Output Complexity Set Discrete State Output Specification Set Model Reference Discrete Sample Time Inheritance Use Update and Output for Nondirect Feedthrough Enable For Each Subsystem Support Define System Object for Use in Simulink Develop System Object for Use in MATLAB System Block Define Block Dialog Box for Plot Ramp Use Global Variables in System Objects System Object Global Variables in MATLAB System Object Global Variables in Simulink System Design in Simulink Using System Objects System Design and Simulation in Simulink Define New System Objects for Use in Simulink Test New System Objects in MATLAB Add System Objects to Your Simulink Model Specify Sample Time for MATLAB System Block System Objects Create Moving Average Filter Block with System Object Process Message Payload Using MATLAB System Block Call Python Function Using MATLAB Function and MATLAB System Block Convert Moving Target MATLAB Code to a Simulink Model Integrate Python Algorithms to Parse NMEA GPS Messages Using Python Importer Manage and Create a Blockset Using Blockset Designer Create a Blockset Project Create a New Blockset Project Create a Project from an Existing Blockset Blockset Project File Structure Create and Organize Block Artifacts Add Tests to Blocks Document the Blocks S-Function Related Artifacts Publish the Created Blockset FMUs and Co-Simulation in Simulink Import FMUs FMU XML File Directives Additional Support and Limitations FMU Import Examples Implement an FMU Block Explore the FMU Block Change Block Input, Output, Parameter and Internal Variable Structures Timing Considerations Troubleshooting FMUs Export a Model as a Tool-Coupling FMU Include Tunable Parameters for Tool-Coupling FMU Use Protected Model to Conceal Content Use the Exported Tool-Coupling FMU Co-Simulation Execution Execution Timing Numerical Compensation Numerical Compensation Prerequisites Manage Numerical Compensation Options Using the Dialog Manage Numerical Compensation Options from the Command Line Numerical Compensation Limitations Run Co-Simulation Components on Multiple Cores Singlethreaded Versus Multithreaded Simulations Using Multithreaded Simulation to Speed up Simulation on Multiple Cores Using the MultithreadedSim Parameter Configuring S-Function Blocks to Run Single or Multithreaded Co-Simulation on Multiple Threads Limitations and Guidelines Simulink Community and Connection Partner Program FMU Block Calling Sequences Co-Simulation Call Sequence for FMI Version 1.0 Model Exchange Call Sequence for FMI Version 1.0 Co-Simulation Call Sequence for FMI Version 2.0 Model Exchange Call Sequence for FMI Version 2.0 Design Considerations for C/C++ Code Generation When to Generate Code from MATLAB Algorithms When Not to Generate Code from MATLAB Algorithms Which Code Generation Feature to Use Prerequisites for C/C++ Code Generation from MATLAB MATLAB Code Design Considerations for Code Generation See Also Differences Between Generated Code and MATLAB Code Functions that have Multiple Possible Outputs Passing Input Argument Name at Run Time Empty Repeating Input Argument Output Argument Validation of Conditionally-Assigned Outputs Writing to ans Variable Logical Short-Circuiting Loop Index Overflow Indexing for Loops by Using Single Precision Operands Index of an Unentered for Loop Character Size Order of Evaluation in Expressions Name Resolution While Constructing Function Handles Termination Behavior Size of Variable-Size N-D Arrays Size of Empty Arrays Size of Empty Array That Results from Deleting Elements of an Array Growing Variable-Size Column Cell Array That is Initialized as Scalar at Run Time Binary Element-Wise Operations with Single and Double Operands Floating-Point Numerical Results NaN and Infinity Negative Zero Code Generation Target MATLAB Class Property Initialization MATLAB Classes in Nested Property Assignments That Have Set Methods MATLAB Handle Class Destructors Variable-Size Data Complex Numbers Converting Strings with Consecutive Unary Operators to double Display Function MATLAB Language Features Supported for C/C++ Code Generation MATLAB Features That Code Generation Supports MATLAB Language Features That Code Generation Does Not Support Functions, Classes, and System Objects Supported for Code Generation Functions and Objects Supported for C/C++ Code Generation System Objects Supported for Code Generation Code Generation for System Objects Defining MATLAB Variables for C/C++ Code Generation Variables Definition for Code Generation Best Practices for Defining Variables for C/C++ Code Generation Explicitly Define Variables Before Using Them Use Caution When Reassigning Variable Properties Define Variable Numeric Data Types Define Matrices Before Assigning Indexed Variables Index Arrays by Using Constant Value Vectors Eliminate Redundant Copies of Variables in Generated Code When Redundant Copies Occur How to Eliminate Redundant Copies by Defining Uninitialized Variables Defining Uninitialized Variables Reassignment of Variable Properties Reuse the Same Variable with Different Properties When You Can Reuse the Same Variable with Different Properties When You Cannot Reuse Variables Limitations of Variable Reuse Supported Variable Types Edit and Represent Coder Type Objects and Properties Object Properties Legacy Representation of Coder Type Objects Defining Data for Code Generation Data Definition Considerations for Code Generation Code Generation for Complex Data Restrictions When Defining Complex Variables Code Generation for Complex Data with Zero-Valued Imaginary Parts Results of Expressions That Have Complex Operands Results of Complex Multiplication with Nonfinite Values Encoding of Characters in Code Generation Array Size Restrictions for Code Generation Code Generation for Constants in Structures and Arrays Code Generation for Strings Limitations Differences Between Generated Code and MATLAB Code Code Generation for Sparse Matrices Code Generation Guidelines Code Generation Limitations Specify Array Layout in Functions and Classes Specify Array Layout in a Function Query Array Layout of a Function Specify Array Layout in a Class Code Design for Row-Major Array Layout Linear Indexing Uses Column-Major Array Layout Generate Code for Growing Arrays and Cell Arrays with end + 1 Indexing Grow Array with (end + 1) Indexing Grow Cell Array with {end + 1} Indexing Code Generation for Variable-Size Data Code Generation for Variable-Size Arrays Memory Allocation for Variable-Size Arrays Enabling and Disabling Support for Variable-Size Arrays Variable-Size Arrays in a MATLAB Function Report Control Dynamic Memory Allocation for Fixed-Size Arrays Enable Dynamic Memory Allocation for Fixed-Size Arrays Dynamic Memory Allocation Threshold for Fixed-Size Arrays Generating Code for Fixed-Size Arrays Usage Notes and Limitations Specify Upper Bounds for Variable-Size Arrays Specify Upper Bounds for MATLAB Function Block Inputs and Outputs Specify Upper Bounds for Local Variables Define Variable-Size Data for Code Generation Use a Matrix Constructor with Nonconstant Dimensions Assign Multiple Sizes to the Same Variable Growing an Array by Using (end + 1) Define Variable-Size Data Explicitly by Using coder.varsize Diagnose and Fix Variable-Size Data Errors Diagnosing and Fixing Size Mismatch Errors Diagnosing and Fixing Errors in Detecting Upper Bounds Incompatibilities with MATLAB in Variable-Size Support for Code Generation Incompatibility with MATLAB for Scalar Expansion Incompatibility with MATLAB in Determining Size of Variable-Size N-D Arrays Incompatibility with MATLAB in Determining Size of Empty Arrays Incompatibility with MATLAB in Determining Class of Empty Arrays Incompatibility with MATLAB in Matrix-Matrix Indexing Incompatibility with MATLAB in Vector-Vector Indexing Incompatibility with MATLAB in Matrix Indexing Operations for Code Generation Incompatibility with MATLAB in Concatenating Variable-Size Matrices Differences When Curly-Brace Indexing of Variable-Size Cell Array Inside Concatenation Returns No Elements Variable-Sizing Restrictions for Code Generation of Toolbox Functions Common Restrictions Toolbox Functions with Restrictions for Variable-Size Data Generate Code With Implicit Expansion Enabled Output Size Additional Code Generation Performance Variation Optimize Implicit Expansion in Generated Code Disable Implicit Expansion in Specified Function by Using coder.noImplicitExpansionInFunction Disable Implicit Expansion for Specific Binary Operation by Using coder.sameSizeBinaryOp Disable Implicit Expansion in your Project Representation of Arrays in Generated Code Customize Interface Generation Control Memory Allocation for Fixed-Size Arrays Enable Dynamic Memory Allocation for All Fixed-Size Arrays Enable Dynamic Memory Allocation for Arrays Bigger Than a Threshold Resolve Error: Size Mismatches Issue Possible Solutions Code Generation for MATLAB Structures Structure Definition for Code Generation Structure Operations Allowed for Code Generation Define Scalar Structures for Code Generation Restrictions When Defining Scalar Structures by Assignment Adding Fields in Consistent Order on Each Control Flow Path Restriction on Adding New Fields After First Use Define Arrays of Structures for Code Generation Ensuring Consistency of Fields Using repmat to Define an Array of Structures with Consistent Field Properties Defining an Array of Structures by Using struct Defining an Array of Structures Using Concatenation Index Substructures and Fields Assign Values to Structures and Fields Pass Large Structures as Input Parameters Code Generation for Cell Arrays Code Generation for Cell Arrays Homogeneous vs. Heterogeneous Cell Arrays Controlling Whether a Cell Array Is Homogeneous or Heterogeneous Cell Arrays in Reports Control Whether a Cell Array Is Variable-Size Cell Array Limitations for Code Generation Cell Array Element Assignment Variable-Size Cell Arrays Definition of Variable-Size Cell Array by Using cell Cell Array Indexing Growing a Cell Array by Using {end + 1} Cell Array Contents Passing Cell Arrays to External C/C++ Functions Use in MATLAB Function Block Code Generation for Categorical Arrays Code Generation for Categorical Arrays Define Categorical Arrays for Code Generation Allowed Operations on Categorical Arrays MATLAB Toolbox Functions That Support Categorical Arrays Define Categorical Array Inputs Define Categorical Array Inputs at the Command Line Representation of Categorical Arrays Categorical Array Limitations for Code Generation Code Generation for Datetime Arrays Code Generation for Datetime Arrays Define Datetime Arrays for Code Generation Allowed Operations on Datetime Arrays MATLAB Toolbox Functions That Support Datetime Arrays Define Datetime Array Inputs Define Datetime Array Inputs at the Command Line Representation of Datetime Arrays Datetime Array Limitations for Code Generation Code Generation for Duration Arrays Code Generation for Duration Arrays Define Duration Arrays for Code Generation Allowed Operations on Duration Arrays MATLAB Toolbox Functions That Support Duration Arrays Define Duration Array Inputs Define Duration Array Inputs at the Command Line Representation of Duration Arrays Duration Array Limitations for Code Generation Code Generation for Tables Code Generation for Tables Define Tables for Code Generation Allowed Operations on Tables MATLAB Toolbox Functions That Support Tables Define Table Inputs Define Table Inputs at the Command Line Representation of Tables Table Limitations for Code Generation Creating Tables Limitations Modifying Tables Limitations Using Table Functions Limitations Code Generation for Timetables Code Generation for Timetables Define Timetables for Code Generation Allowed Operations on Timetables MATLAB Toolbox Functions That Support Timetables Define Timetable Inputs Define Timetable Inputs at the Command Line Representation of Timetables Timetable Limitations for Code Generation Creating Timetables Limitations Modifying Timetables Limitations Using Timetable Functions Limitations Code Generation for MATLAB Classes MATLAB Classes Definition for Code Generation Language Limitations Code Generation Features Not Compatible with Classes Defining Class Properties for Code Generation Inheritance from Built-In MATLAB Classes Not Supported Classes That Support Code Generation Generate Code for MATLAB Value Classes Generate Code for MATLAB Handle Classes and System Objects Code Generation for Handle Class Destructors Guidelines and Restrictions Behavioral Differences of Objects in Generated Code and in MATLAB Class Does Not Have Property Solution Passing By Reference Not Supported for Some Properties Handle Object Limitations for Code Generation A Variable Outside a Loop Cannot Refer to a Handle Object Allocated Inside a Loop A Handle Object That a Persistent Variable Refers To Must Be a Singleton Object References to Handle Objects Can Appear Undefined System Objects in MATLAB Code Generation Usage Rules and Limitations for System Objects for Generating Code System Objects in codegen System Objects in the MATLAB Function Block System Objects in the MATLAB System Block System Objects and MATLAB Compiler Software Work Around Language Limitation: Code Generation Does Not Support Object Arrays Issue Possible Solutions Code Generation for Function Handles Function Handle Limitations for Code Generation Defining Functions for Code Generation Code Generation for Variable Length Argument Lists Generate Code for arguments Block That Validates Input and Output Arguments Supported Features Names Must Be Compile-Time Constants Using the Structure That Holds Name-Value Arguments Differences Between Generated Code and MATLAB Code Code Generation for Anonymous Functions Anonymous Function Limitations for Code Generation Code Generation for Nested Functions Nested Function Limitations for Code Generation Calling Functions for Code Generation Resolution of Function Calls for Code Generation Key Points About Resolving Function Calls Compile Path Search Order When to Use the Code Generation Path Resolution of File Types on Code Generation Path Compilation Directive %#codegen Use MATLAB Engine to Execute a Function Call in Generated Code When To Declare a Function as Extrinsic Use the coder.extrinsic Construct Call MATLAB Functions Using feval Working with mxArrays Restrictions on Using Extrinsic Functions Code Generation for Recursive Functions Compile-Time Recursion Run-Time Recursion Disallow Recursion Disable Run-Time Recursion Recursive Function Limitations for Code Generation Force Code Generator to Use Run-Time Recursion Treat the Input to the Recursive Function as a Nonconstant Make the Input to the Recursive Function Variable-Size Assign Output Variable Before the Recursive Call Avoid Duplicate Functions in Generated Code Issue Cause Solution Improve Run-Time Performance of MATLAB Function Block Avoid Data Copies of Function Inputs in Generated Code Inline Code Unroll for-Loops and parfor-Loops Force for-Loop Unrolling by Using coder.unroll Generate Reusable Code LAPACK Calls for Linear Algebra in a MATLAB Function Block BLAS Calls for Matrix Operations in a MATLAB Function Block FFTW calls for fast Fourier transform functions in a MATLAB Function Block Troubleshooting MATLAB Code in MATLAB Function Blocks Compile-Time Recursion Limit Reached Issue Cause Solutions Force Run-Time Recursion Increase the Compile-Time Recursion Limit Output Variable Must Be Assigned Before Run-Time Recursive Call Issue Cause Solution Unable to Determine That Every Element of Cell Array Is Assigned Issue Cause Solution Nonconstant Index into varargin or varargout in a for-Loop Issue Cause Solution Unknown Output Type for coder.ceval Issue Cause Solution Managing Data Working with Data About Data Types in Simulink Data Typing Guidelines Data Type Propagation Data Types Supported by Simulink Block Support for Data and Signal Types Control Data Types of Signals Entering Valid Data Type Values Use the Model Data Editor for Batch Editing Share a Data Type Between Separate Algorithms, Data Paths, Models, and Bus Elements Reuse Custom C Data Types for Signal Data Determine Data Type of Signal That Uses Inherited Setting Data Types Remain double Despite Changing Settings Validate a Floating-Point Embedded Model Explore the Model Validate a Single-Precision Model Blocks That Support Single Precision Fixed-Point Numbers Binary Point Interpretation Signed Fixed-Point Numbers Benefits of Using Fixed-Point Hardware Scaling, Precision, and Range Scaling Precision Range Fixed-Point Data in MATLAB and Simulink Fixed-Point Data in Simulink Fixed-Point Data in MATLAB Scaled Doubles Share Fixed-Point Models Control Fixed-Point Instrumentation and Data Type Override Control Instrumentation Settings Control Data Type Override Instrumentation Settings and Data Type Override for a Model Reference Hierarchy Specify Fixed-Point Data Types Overriding Fixed-Point Specifications Specify Data Types Using Data Type Assistant Specifying a Fixed-Point Data Type Specify an Enumerated Data Type Specify a Bus Object Data Type Specify an Image Data Type Specify a Value Type Data Types for Buses Simulink Strings String Constants Simulink Strings and Null Characters String Data Type Strings in Bus Objects Strings and Generated Code String Data Type Conversions Display and Extract Coordinate Data Find Patterns in Strings Extract a String Get Text Following a Keyword Change Existing Models to Use Strings Parse NMEA GPS Text Message Simulink String Limitations Data Objects Data Class Naming Conventions Use Data Objects in Simulink Models Data Object Properties Create Data Objects from Built-In Data Class Package Simulink Create Data Objects from Another Data Class Package Create Data Objects Directly from Dialog Boxes Create Data Objects for a Model Using Data Object Wizard Create Data Objects from External Data Source Programmatically Data Object Methods Handle Versus Value Classes Compare Data Objects Resolve Conflicts in Configuration of Signal Objects for Code Generation Create Persistent Data Objects Simulink.DualScaledParameter Property Dialog Box Main Attributes Tab Calibration Attributes Tab Simulink.NumericType Property Dialog Box Use Simulink.Signal Objects to Specify and Control Signal Attributes Using Signal Objects to Assign or Validate Signal Attributes Validation Multiple Signal Objects Signal Specification Block: An Alternative to Simulink.Signal Bus Support Define Data Classes Use an example to define data classes Manually define data class Optional: Add properties to data class Optional: Add initialization code to data class Optional: Define storage classes Optional: Define custom attributes for storage classes Determine Where to Store Variables and Objects for Simulink Models Types of Data Store Data for Your Design Storage Locations Create, Edit, and Manage Workspace Variables Tools for Managing Variables Edit Variable Value or Property from Block Parameter Modify Structure and Array Variables Interactively Ramifications of Modifying or Deleting a Variable Analyze Variable Usage in a Model Rename a Variable Throughout a Model Interact with Variables Programmatically Edit and Manage Workspace Variables by Using Model Explorer Finding Variables That Are Used by a Model or Block Finding Blocks That Use a Specific Variable Finding Unused Workspace Variables Editing Workspace Variables Rename Variables Compare Duplicate Workspace Variables Export Workspace Variables Importing Workspace Variables Model Workspaces Model Workspace Differences from MATLAB Workspace Troubleshooting Memory Issues Manipulate Model Workspace Programmatically Specify Source for Data in Model Workspace Data source MAT-File and MATLAB File Source Controls MATLAB Code Source Controls Change Model Workspace Data Change Workspace Data Whose Source Is the Model File Change Workspace Data Whose Source Is a MAT-File or MATLAB File Changing Workspace Data Whose Source Is MATLAB Code Use MATLAB Commands to Change Workspace Data Create Model Mask Create External File Adapter for Loading Variables into Simulink.SimulationInput Object Write Class Definition for Custom File Adapter Test Custom File Adapter Register Custom File Adapter Use Custom File Adapter to Load Variables for Simulation Symbol Resolution Symbols Symbol Resolution Process Numeric Values with Symbols Other Values with Symbols Limit Signal Resolution Explicit and Implicit Symbol Resolution Upgrade Level-1 Data Classes Associating User Data with Blocks Support Limitations for Simulink Software Features Supported and Unsupported Simulink Blocks Support Limitations for Stateflow Software Features ml Namespace Operator, ml Function, ml Expressions C or C++ Operators C Math Functions Atomic Subcharts That Call Exported Graphical Functions Outside a Subchart Atomic Subchart Input and Output Mapping Recursion and Cyclic Behavior Custom C/C++ Code Textual Functions with Literal String Arguments Custom State Attributes in Discrete FIR Filter block Open Model Data Editor Build the Model and Inspect the Generated Code Enumerations and Modeling Simulink Enumerations Simulink Constructs that Support Enumerations Simulink Enumeration Limitations Use Enumerated Data in Simulink Models Define Simulink Enumerations Simulate with Enumerations Specify Enumerations as Data Types Get Information About Enumerated Data Types Enumeration Value Display Instantiate Enumerations Enumerated Values in Computation Create Data to Use as Simulation Input Create and Edit Signal Data Differences Between the Root Inport Mapper Signal Editor and Other Signal Editors Table Editing Data Support Add and Edit Multidimensional Signals Draw a Ramp Using Snap to Grid for Accuracy Save and Send Changes to the Root Inport Mapper Tool Use Scenarios and Insert Signals in Signal Editor Use Scenarios to Group and Organize Inputs Link in Signal Data from Signal Builder Block and Simulink Design Verifier Environment Insert Signals Add Signals to Scenarios Create Signal Data Using Standard Waveforms Work with Basic Signal Data Create Signals and Signal Data Work with Basic Signal Data with a Tabular Editor Create Signals with MATLAB Expressions and Variables Replace Signal Data with MATLAB Expressions Create Freehand Signal Data Using Mouse or Multi-Touch Gestures Import Custom File Type Create Custom File Type for Import to Signal Editor Define New FileType Object for Use in Simulink Define FileType Object Create sldvData Custom File Type Reader to Import to Signal Editor Export Signals to Custom Registered File Types Load Simulation Input Data Provide Signal Data for Simulation Identify Model Signal Data Requirements Signal Data Storage for Loading Load Input Signal Data Log Output Signal Data Load Big Data for Simulations Stream Individual Signals Using SimulationDatastore Objects Stream Entire Dataset Using DatasetRef Object Load Individual Signals from a DatasetRef Object Stream Data from a MAT-File as Input for a Parallel Simulation Overview of Signal Loading Techniques Source Blocks Root-Level Input Ports From File Block From Spreadsheet Block From Workspace Block Signal Editor Block Comparison of Signal Loading Techniques Techniques Impact of Loading Techniques on Block Diagrams Comparison of Techniques Control How Models Load Input Data Configure Input Data Interpolation Capture Dynamics of Input Data Load Data as Continuous Signal Load Data as Discrete Signal Load Data Logged In Another Simulation Load Logged Data Configure Logging to Meet Loading Requirements Load Data to Model Variable-Step Input from Model Hierarchy Load Input Data for Basic Test Cases Load Data to Root-Level Input Ports Specify Input Data Forms of Input Data Time Values for the Input Parameter Data Loading Loading Dataset Data to Root-Level Inputs Loading MATLAB Timeseries Data to Root-Level Inputs Loading MATLAB Timetable Data to Root-Level Inputs Loading Data Structures to Root-Level Inputs Loading Data Arrays to Root-Level Inputs Loading MATLAB Time Expressions to Root Inports Load Bus Data to Root-Level Input Ports Imported Bus Data Requirements Open Example Materials Import Bus Data to a Top-Level Inport Get Information About Bus Objects Create Structures of Timeseries Objects from Buses Import Array of Buses Data Load Input Data for a Bus Using In Bus Element Blocks Load Signal Data That Uses Units Loading Bus Signals That Have Units Load Data Using the From File Block Load Data Using the From Workspace Block Load Data Using Playback Block Load State Information Import Initial States Initialize a State Initialize States in Referenced Models Load Simulation Inputs Using the Root Inport Mapper Map Data Using Root Inport Mapper Tool The Model Create Signal Data Import and Visualize Workspace Signal Data Map the Data to Inports Save the Mapping and Data Simulate the Model Map Root Inport Signal Data Command-Line Interface Import and Mapping Workflow View and Inspect Signal Data Create Signal Data for Root Inport Mapping Choose a Source for Data to Import and Map Choose a Naming Convention for Signals and Buses Choose a Base Workspace and MAT-File Format Bus Signal Data for Root Inport Mapping Create Signal Data in a MAT-File for Root Inport Mapping Import Signal Data for Root Inport Mapping Import Signal Data Import Bus Data Import Signal Data from Other Sources Import Data from Signal Editor Import Test Vectors from Simulink Design Verifier Environment Map Signal Data to Root Input Ports Select Map Mode Set Options for Mapping Select Data to Map Map Data Understand Mapping Results Alternative Workflows to Load Mapping Data Preview Signal Data Generate MATLAB Scripts for Simulation with Scenarios Create and Use Custom Map Modes Create Custom Mapping File Function Root Inport Mapping Scenarios Open Scenarios Save Scenarios Open Existing Scenarios Work with Multiple Scenarios Load Data with Interchangeable Scenarios Load Data with Interchangeable Scenarios Using Signal Editor Block Explore the Signal Editor Block Get Number of Scenarios and Signals Migrate from Signal Builder Block to Signal Editor Block Replace Signal Builder Block with Signal Editor Block Replace Programmatic Use of signalbuilder Importing and Exporting Simulation Data Save Simulation Data Choose Type of Simulation Data to Log Choose Technique to Log Simulation Data Log Data View and Access Logged Simulation Data View Logged Data Using Simulation Data Inspector Access Logged Data Programmatically Data Format for Logged Simulation Data Data Format for Block-Based Logged Data Data Format for Model-Based Logged Data Signal Logging Format Logged Data Store Format Time, State, and Output Data Format Convert Data to Dataset Format Why Convert to Dataset Format? Results of Conversion Convert timeseries object to Dataset object Convert Structure to Dataset Object Migrate Legacy Code That Uses ModelDataLogs Dataset Conversion Limitations Limit the Size of Logged Data Limit the Number of Runs Retained in the Simulation Data Inspector Archive Specify a Minimum Disk Space Requirement or Maximum Size for Logged Data View Data Only During Simulation Reduce the Number of Data Points Logged from Simulation Specify Signal Values to Log Decimation Log Last n Signal Values Specify Logging Intervals Work with Big Data for Simulations Big Data Workflow Log Data to Persistent Storage When to Log to Persistent Storage Log to Persistent Storage Enable Logging to Persistent Storage Programmatically How Simulation Data Is Stored Save Logged Data from Successive Simulations Analyze Big Data from a Simulation Create DatasetRef Objects to Access Logged Datasets Use SimulationDatastore Objects to Access Signal Data Create Timetables for MATLAB Analysis Create Tall Timetables Access Persistent Storage Metadata Access Error Information Samples to Export for Variable-Step Solvers Output Options Refine Output Produce Additional Output Produce Specified Output Only Save Signal Data Using Signal Logging Open Model Enable Signal Logging for Model Mark Signals for Logging Specify Signal Names Simulate Model and View Data Access Signal Logging Data Programmatically View the Signal Logging Configuration Approaches for Viewing the Signal Logging Configuration View Signal Logging Configuration Using the Simulink Editor View Logging Configuration Using the Signal Logging Selector View Signal Logging Configuration Using the Model Explorer Programmatically Find Signals Configured for Logging Override Signal Logging Settings Benefits of Overriding Signal Logging Settings Two Interfaces for Overriding Signal Logging Settings Scope of Signal Logging Setting Overrides Override Signal Logging Settings with Signal Logging Selector Override Signal Logging Settings from MATLAB View and Access Signal Logging Data Signal Logging Object Access Data Programmatically Handling Spaces and Newlines in Logged Names Access Logged Signal Data in ModelDataLogs Format Log Signals in For-Each Subsystems Log Signal in Nested For-Each Subsystem Log Bus Signals in For-Each Subsystem Save Block States and Simulation Operating Points Choose Which State Information to Log Choose Format for Logged State Information Save State Information Save State Information for Each Simulation Step Save Partial Final State Information Examine State Information Saved Without the Operating Point Save Final State Information with Operating Point Log Data to the Workspace and a File Using the Record Block Working with Data Stores Data Store Basics When to Use a Data Store Local and Global Data Stores Data Store Diagnostics Specify Initial Value for Data Store Model Global Data by Creating Data Stores Data Store Examples Create and Apply Data Stores Data Stores with Data Store Memory Blocks Data Stores with Signal Objects Access Data Stores with Simulink Blocks Order Data Store Access Data Stores with Buses and Arrays of Buses Accessing Specific Bus and Matrix Elements Rename Data Stores Customized Data Store Access Functions in Generated Code Log Data Stores Logging Local and Global Data Store Values Supported Data Types, Dimensions, and Complexity for Logging Data Stores Data Store Logging Limitations Logging Data Stores Created with a Data Store Memory Block Logging Icon for the Data Store Memory Block Logging Data Stores Created with a Simulink.Signal Object Accessing Data Store Logging Data Simulink Data Dictionary What Is a Data Dictionary? Dictionary Capabilities Sections of a Dictionary Dictionary Usage for Models Created with Different Versions of Simulink Manage and Edit Entries in a Dictionary Dictionary Referencing Import and Export File Formats Allow Access to Base Workspace Migrate Models to Use Simulink Data Dictionary Migrate Single Model to Use Dictionary Migrate Model Reference Hierarchy to Use Dictionary Considerations Before Migrating to Data Dictionary Continue to Use Shared Data in the Base Workspace Migrate Complicated Model Hierarchy with Shared Data Enumerations in Data Dictionary Migrate Enumerated Types into Data Dictionary Manipulate Enumerations in Data Dictionary Remove Enumerated Types from Data Dictionary Import and Export Dictionary Data Import Data to Dictionary from File Export Design Data from Dictionary View and Revert Changes to Dictionary Data View and Revert Changes to Dictionary Entries View and Revert Changes to Entire Dictionary Partition Dictionary Data Using Referenced Dictionaries Partition Data for Model Reference Hierarchy Using Data Dictionaries Open the Example Model and Load Design Data Create a Dictionary for Each Component Strategies to Discover Shared Data Attach Data Dictionary to Custom Libraries Author Library Blocks with Data Types Defined in Attached Data Dictionary Use Blocks From a Library with Attached Data Dictionary Considerations When Using a Library Dictionary Store Data in Dictionary Programmatically Add Entry to Design Data Section of Data Dictionary Rename Data Dictionary Entry Increment Value of Data Dictionary Entry Data Dictionary Management Dictionary Section Management Dictionary Entry Manipulation Transition to Using Data Dictionary Programmatically Migrate Single Model to Use Dictionary Import Directly From External File to Dictionary Programmatically Partition Data Dictionary Make Changes to Configuration Set Stored in Dictionary Attach Data Dictionary to Subsystem Reference Attach Data Dictionary to a Subsystem File Symbol Resolution Process Considerations and Limitations Managing Signals Working with Signals Signal Basics Signal Line Styles Signal Properties Signal Names and Labels Signal Display Options Store Design Attributes of Signals and States Test Signals Signal Types Control Signals Composite Signals Virtual and Nonvirtual Signals Investigate Signal Values Initialize Signal Values View Signal Values Display Signal Values in Model Diagrams Signal Data Types Complex Signals Exporting Signal Data Signal Label Propagation Blocks That Support Signal Label Propagation How Simulink Propagates Signal Labels Display Propagated Signal Labels Special Cases of Signal Propagation Determine Signal Dimensions Simulink Blocks that Support Multidimensional Signals Determine the Output Dimensions of Source Blocks Determine the Output Dimensions of Nonsource Blocks Signal and Parameter Dimension Rules Scalar Expansion of Inputs and Parameters Highlight Signal Sources and Destinations Highlight Signal Source Highlight Signal Destination Choose the Path of a Trace Trace a Signal To and From Subsystems Show All Possible Paths of a Trace Display Port Values Along a Trace Remove Highlighting Resolve Incomplete Highlighting to Library Blocks Signal Highlighting in Variant Systems Limitations Bus Element Tracing and Highlighting Specify Signal Ranges Blocks That Allow Signal Range Specification Work with Signal Ranges in Blocks Troubleshoot Signal Range Errors Unexpected Errors or Warnings for Data with Greater Precision or Range than double Initialize Signals and Discrete States Using Block Parameters to Initialize Signals and Discrete States Use Signal Objects to Initialize Signals and Discrete States Using Signal Objects to Tune Initial Values Initialization Behavior Summary for Signal Objects Configure Signals as Test Points What Is a Test Point? Displaying Test Point Indicators Specify Application-Specific Signal Properties Determine Whether To Use Value Types Create Value Types Specify Value Types Save Value Types Map Value Types to Models Display Signal Attributes Ports & Signals Menu Port Data Types Design Ranges Signal Dimensions Signal to Object Resolution Indicator Wide Nonscalar Lines Signal Groups About Signal Groups Using the Signal Builder Block with Fast Restart Editing Signal Groups Editing Signals Creating Signal Group Sets Manually Signal Data Files and Data Reformatting Function for Following Procedures Importing Signal Group Sets Importing Data with Custom Formats Editing Waveforms Signal Builder Time Range Exporting Signal Group Data Simulating with Signal Groups Simulation from Signal Builder Block Using Composite Interfaces Composite Interface Guidelines Visualize Composite Interfaces Define Composite Interfaces Choose Among Composite Interfaces Composite Interfaces High-Level Composite Interface Selection Guidelines Modeling Requirement Considerations Compare Capabilities of Composite Interfaces Composite Interface Elements Composite Interface Modeling Composite Interface Code Generation Group Signals or Messages into Virtual Buses Group Signal Lines Within a Component Connect Multiple Output Signals to a Port Combine Multiple Subsystem Ports into One Port Simplify Subsystem and Model Interfaces with Bus Element Ports Combine Multiple Subsystem Ports into One Port Simplify Bus Interfaces in Subsystems and Models Use Buses at Model Interfaces Modify Bus Hierarchy Resolve Circular Dependencies in Buses Create Nonvirtual Buses Create Nonvirtual Buses Within a Component Create Nonvirtual Buses at Interfaces Convert Virtual Bus to Nonvirtual Bus Create Nonvirtual Bus from MATLAB Structure Display Bus Information Display Bus Hierarchy Display Value of Bus Elements Programmatically Get Bus Hierarchy and Virtuality Bus-Capable Blocks Assign Signal Values to Bus Elements Identify Automatic Bus Conversions Bus-to-Vector Conversions Virtual and Nonvirtual Bus Conversions Modify Sample Times for Nonvirtual Buses Specify Bus Properties with Simulink.Bus Object Data Types Simulink.Bus Object Workflow Determine Whether to Use Simulink.Bus Objects Determine How to Manage Simulink.Bus Objects Create and Specify Simulink.Bus Objects Save Simulink.Bus Objects Map Simulink.Bus Objects to Models Programmatically Create Simulink Bus Objects Create Bus Objects from Bus Element Objects Create Bus Objects from Blocks Create Bus Objects from MATLAB Data Create Bus Objects from External C Code Specify Initial Conditions for Bus Elements Blocks That Support Bus Initialization Set Diagnostics to Support Bus Initialization Create Initial Condition Structures Control Data Types of Structure Fields Create Full Structures for Initialization Create Partial Structures for Initialization Initialize Buses Using Block Parameters Group Nonvirtual Buses in Arrays of Buses Requirements of Arrays of Buses Create Array of Buses from Nonvirtual Buses Create Array of Buses from MATLAB Structures Work with Arrays of Buses Perform Iterative Processing Assign Values into Arrays of Buses Select Bus Elements from Array of Buses Import Array of Buses Data Log Arrays of Buses Initialize Arrays of Buses Code Generation Programmatically Initialize Arrays of Buses Assign into Elements of Array of Buses Iteratively Process Nonvirtual Buses with Arrays of Buses Share and Reuse Bus-Routing Blocks Generate Code for Nonvirtual Buses Control Data Types of Initial Condition Structure Fields Code Generation for Arrays of Buses Inspect Generated Code for Nonvirtual Buses Trace Connections Using Interface Display Trace Connections in a Subsystem Working with Variable-Size Signals Variable-Size Signal Basics How Variable-Size Signals Propagate Determine Whether Signal Line Has Variable Size Empty Signals Simulink Block Support for Variable-Size Signals Variable-Size Signal Limitations Inspect Variable-Size Signals on Simulink Models Variable-Size Signal Generation and Operations Variable-Size Signal Length Adaptation Mode-Dependent Variable-Size Signals S-Functions Using Variable-Size Signals Customizing Simulink Environment and Printed Models Customizing the Simulink User Interface Access Frequently Used Features and Commands in Simulink Search for Simulink Toolstrip Actions Rerun Favorite Commands for Simulink Share Favorite Commands for Simulink Create Custom Simulink Toolstrip Tabs Start Simulink Create Simulink Toolstrip Component Add Blank Tab to Simulink Toolstrip Open JSON File to Develop Custom Tab Define Custom Tab Layout Choose Among Types of Controls Get Built-In Simulink Actions Specify Built-In Simulink Actions Define Custom Actions Choose Among Pop-Up List Elements Define Pop-Up Lists Share Custom Tabs Add Prepopulated Custom Tab to Simulink Toolstrip Add Items to Model Editor Menus Code for Adding Menu Items Define Menu Items Register Menu Customizations Callback Info Object Debugging Custom Menu Callbacks Menu Tags Disable Simulink Toolstrip and Context Menu Actions Get Built-In Simulink Actions Set Up Customization File Create Filter Functions Register Filter Functions Read and Refresh Customization Files Disable and Hide Dialog Box Controls About Disabling and Hiding Controls Disable a Button on a Dialog Box Write Control Customization Callback Functions Dialog Box Methods Widget IDs Register Control Customization Callback Functions Customize Library Browser Appearance Reorder Libraries Disable and Hide Libraries Expand or Collapse Library in Browser Tree Improve Quick Block Insert Results Register Customizations with Simulink Set Up Customization File Edit the Customization File Read and Refresh Customization Files Frames for Printed Models Create Print Frames for Printed Pages PrintFrame Editor Create a Print Frame Add Rows and Cells to Print Frames Add Content to Print Frame Cells Format Content in Cells Running Models on Target Hardware About Run on Target Hardware Feature Simulink Supported Hardware Block Produces Zeros or Does Nothing in Simulation Running Simulations in Fast Restart How Fast Restart Improves Iterative Simulations Limitations Get Started with Fast Restart Prepare a Model to Use Fast Restart Fast Restart Methodology Model Component Testing Component Verification Component Verification Use Foundational Blocks Perform Rigorous Component Verification Run Polyspace Analysis on Generated Code by Using Packaged Options Files Generate and Package Polyspace Options Files Run Polyspace Analysis by Using the Packaged Options Files Analyze Code Generated as Standalone Code in a Distributed Workflow Open Model for Distributed Analysis Configure Model Generate Code Archive Generate and Package Polyspace Options File Run Polyspace Analysis by Using the Packaged Options Files Manage a Variant Model Using Variant Manager Variant Configurations What is a Variant Configuration? Types of Variant Configurations Constraints on Variant Configurations Variant Configuration Data Object Activate a Variant Configuration Differences Between Variant Manager Activation and Update Diagram Process Referenced Component Configurations Preferred Configuration Variant Manager View of Variant Configurations Limitations Create and Activate Variant Configurations Steps to Create Variant Configurations Open Variant Manager Configurations Tab in Variant Manager Add New Variant Configuration Add, Import, or Export Control Variables in Variant Configuration Edit Control Variables in Variant Configuration Set Up Variant Configurations for Referenced Components Define Constraints for Variant Configurations Save Variant Configurations Validate and Activate Variant Configuration Save and Reuse Variant Configurations Using Variant Configuration Data Object Generate Variant Configurations Automatically Generate Variant Configurations Using Variant Manager Steps to Generate Configurations Limitations Reduce Variant Models Using Variant Reducer Variant Reducer Reduce Variant Model Using Variant Manager Explore Variant Reducer Summary Reduce a Model Programmatically Considerations and Limitations for Variant Reduction Analyze Variant Configurations in Models Containing Variant Blocks Analyze Variant Configurations Using Variant Analyzer Run Variant Analyzer Explore Variant Analysis Report Analyze Variant Configurations Programmatically Limitations Reduce Model Containing Variant Blocks Variant Manager Workflow to Set Up Variant Configurations for Models Variant Manager Workflow to Manage Existing Variant Configurations in Models Compatibility Considerations When Using Variant Manager for Simulink Support Package Changes to the Simulink.VariantConfigurationData class Changes to the Simulink.VariantManager class Variant Reducer and Variant Analyzer Reduce Model Containing Variant Parameters Compose Variant Configurations for Top Model Using Referenced Model Configurations Open Component Configurations View Select Variant Configuration for Referenced Component Clear Selected Variant Configuration Component Configurations View Example Validate That Top-Level Model Uses Referenced Component Configuration Validate and Activate Variant Configurations Analyze Variant Configurations Programmatically Generate Variant Configurations Programmatically Find Variant Control Variables for Model Reduce Models Containing Referenced Subsystems Integrate Python Code With Simulink Overview of Integrating Python Code with Simulink Configure System to Use Python Integrate Python Code with Simulink Using MATLAB Function Block Integrate Python Code with Simulink Using MATLAB System Block Import Python Code to Simulink Using Python Importer Wizard Configure System to Use Python Use Python Importer with Blockset Designer Use Python Importer as a Standalone Application Vary Block Parameter Values Conditionally Using Variant Parameters Use Variant Parameters to Reuse Block Parameters with Different Values When to Create Variant Parameters Advantages of Using Variant Parameters Limitations of Using Variant Parameters Create a Simple Variant Parameter Model Variant Control Mode in Variant Parameters Switch Between Choices Using Condition Expressions in Variant Parameters Variant Activation Times for Different Variant Control Modes in Variant Parameters Use Variant Control Variables in Variant Parameters Numeric Variant Control Values for Rapid Prototyping of Variant Parameters Simulink.Parameter Type of Variant Control Variables for Code Generation of Variant Parameters Enumerated Types to Improve Code Readability of Variant Control Variables of Variant Parameters Simulink.Variant Objects for Variant Condition Reuse of Variant Parameters Change Active Values and Activation Time of Variant Parameters Improve Code Readability of Variant Parameters Using Enumerated Types Compile Code Conditionally for All Values of Variant Parameters with Same and Different Dimensions Run Executable for Different Variant Parameter Values Without Recompiling Code Reuse Variant Parameter Values from Handwritten Code Using Simulink.Parameter Variables Group Variant Parameter Values in Code Using Variant Parameter Bank