find_system

R2026b

查找模型、模块、信号线、端口和注解

全页折叠

语法

Objects = find_system

Objects = find_system(Model)

Objects = find_system(Name=Value)

Objects = find_system(Model,Name=Value)

描述

Objects = find_system 返回加载的模型及其模块，包括子系统。

Objects = find_system(Model) 返回指定的模型及其模块。

示例

Objects = find_system(Name=Value) 返回加载的模型以及这些模型中满足一个或多个 Name=Value 对组参量指定的条件的对象。您可以使用此语法指定搜索约束和搜索特定的参数值。在参数和值对组之前指定搜索约束。

Objects = find_system(Model,Name=Value) 返回指定模型中满足指定条件的对象。

示例

全部折叠

获取模型中模块的路径

假设您有已加载的名为 myModel 的模型。

获取模型名称和模型包含的所有模块的路径。

p = find_system("myModel",Type="block")

获取模型中模块的句柄

假设您有已加载的名为 myModel 的模型。获取模型包含的所有模块的句柄。

获取模型句柄。

hModel = get_param("myModel","Handle");

获取模型包含的所有模块的句柄。

hBlocks = find_system(hModel,Type="block")

获取子系统中特定类型模块的句柄

假设您有一个名为 myModel 的已加载模型，它包含一个名为 mySubsystem 的 Subsystem 模块。获取子系统包含的所有 Transfer Fcn 模块的句柄。

获取 Subsystem 模块的句柄。

hModel = get_param("myModel/mySubsystem","Handle");

获取子系统包含的所有 Transfer Fcn 模块的句柄。

hBlocks = find_system(hModel,BlockType="TransferFcn")

获取具有特定参数值的模块的句柄

假设您有已加载的名为 myModel 的模型。获取模型中初始条件为零的所有 Integrator 模块的句柄。

获取模型的句柄。

hModel = get_param("myModel","Handle");

获取 InitialCondition 参数值为 0 的所有 Integrator 模块的句柄。

hBlocks = find_system(hModel,BlockType="Integrator",InitialCondition="0")

使用正则表达式获取名称包含关键字的模块的句柄

假设您有已加载的名为 myModel 的模型。获取模型中名称包含关键字 speed 的所有 Subsystem 模块的句柄

获取模型的句柄。

hModel = get_param("myModel","Handle");

获取名称包含关键字 speed 的所有 Subsystem 模块的句柄。

hBlocks = find_system(hModel,Regexp="on",CaseSensitive="off",BlockType="Subsystem",Name='.*speed.*')

获取模型中信号线的句柄

假设您有一个名为 myModel 的已加载模型，它包含一个名为 mySubsystem 的 Subsystem 模块。获取子系统包含的所有信号线的句柄。

获取 Subsystem 模块的句柄。

hModel = get_param("myModel/mySubsystem","Handle");

获取子系统包含的所有信号线的句柄。请记住将 FindAll 设置为 "on" 以便在搜索中包括信号线、端口和注解。然后，通过将 Type 设置为 "line" 将搜索范围缩小到仅信号线。

hLines = find_system(h,FindAll="on",Type="line")

要检查您的工作，请打开子系统。

open_system(h);

突出显示其句柄存储在 hLines 中的信号线。

hilite_system(hLines)

获取已加载模型、库和子系统的名称

获取所有已加载的、保存到其自身文件的模型、库和子系统的名称。

find_system(Type="block_diagram")

更新子系统中的库链接

假设您有一个名为 myModel 的模型，它包含一个库链接子系统。上次打开模型后，向库中对应的子系统中添加了一个 Gain 模块。

打开模型。使用 find_system 函数并将 SearchInsideLibraryLinks 设置为 "off"。此命令不会跟随库链接进入子系统，并且只返回顶层子系统。

open_system("myModel")
find_system(bdroot,SearchUnderMasks="all",'SearchInsideLibraryLinks="off")

ans = 

    'myModel'
    'myModel/Subsystem'

使用 find_system 函数并将 SearchInsideLibraryLinks 设置为 "on"。find_system 函数更新库链接并返回子系统中的模块。

find_system(bdroot,SearchUnderMasks="all",SearchInsideLibraryLinks="on")

Updating Link: myModel/Subsystem/Gain
Updating Link: myModel/Subsystem/Gain

ans = 

    'myModel'
    'myModel/Subsystem'
    'myModel/Subsystem/Gain'

使用自定义 `MatchFilter` 函数过滤 `find_system` 搜索

打开实时脚本

您可以使用 MatchFilter 参量来指定要包含在搜索中的元素，这些元素由自定义过滤器函数定义。

例如，要从搜索中排除模型中的 Inport 和 Outport 模块，请按文件 nonInOutBlocks.m 中所示定义自定义过滤器函数。该函数检查每个模块的类型，并仅为 Inport 或 Outport 之外的模块返回 true。

type nonInOutBlocks.m

function match = nonInOutBlocks(handle)
match = true;
if strcmp(get_param(handle, 'Type'), 'block')
  blockType = get_param(handle, 'BlockType');
  if strcmp(blockType, 'Inport') || ...
        strcmp(blockType,  'Outport')
      match = false;
  end
end
end

要将此滤波器应用于 slexVariantSubsystemEnableChoice 模型，请在 find_system 命令中提供函数句柄作为 MatchFilter 参量的值。

load_system("slexVariantSubsystemEnableChoice");
blks = find_system("slexVariantSubsystemEnableChoice","MatchFilter",@nonInOutBlocks)

blks = 12×1 cell
    {'slexVariantSubsystemEnableChoice'                                     }
    {'slexVariantSubsystemEnableChoice/Controller'                          }
    {'slexVariantSubsystemEnableChoice/Controller/Enable'                   }
    {'slexVariantSubsystemEnableChoice/Controller/Linear'                   }
    {'slexVariantSubsystemEnableChoice/Controller/Linear/Enable'            }
    {'slexVariantSubsystemEnableChoice/Controller/Linear/Discrete Filter'   }
    {'slexVariantSubsystemEnableChoice/Controller/Nonlinear'                }
    {'slexVariantSubsystemEnableChoice/Controller/Nonlinear/Enable'         }
    {'slexVariantSubsystemEnableChoice/Controller/Nonlinear/Discrete Filter'}
    {'slexVariantSubsystemEnableChoice/Controller/Nonlinear/Lookup Table'   }
    {'slexVariantSubsystemEnableChoice/Sine Wave'                           }
    {'slexVariantSubsystemEnableChoice/help'                                }

使用 `find_system` 和内置的 `MatchFilter` 函数查找变体模块

此示例使用:

打开实时脚本

Simulink® 提供内置函数，可用于查找模型中的变体模块。有关详细信息，请参阅MatchFilter。

加载 slexVariantSubsystems 模型。

model = 'slexVariantSubsystems';
load_system(model);
assignin('base','VSS_MODE',2);

使用 Simulink.match.activeVariants 函数查找模型编译后在仿真中活动的模块。

set_param(model,'SimulationCommand','update');
find_system(model,'MatchFilter',@Simulink.match.activeVariants);

使用 Simulink.match.codeCompileVariants 函数查找模型编译后生成的 C 代码中的模块。

slexVariantSubsystems([],[],[],'compileForCodegen');
find_system(model,'MatchFilter',@Simulink.match.codeCompileVariants);
slexVariantSubsystems([],[],[],'term');

注意：为了获得正确的结果，在使用 Simulink.match.activeVariants 和 Simulink.match.codeCompileVariants 过滤器之前，您必须编译模型。如果模型未编译，这些过滤器将返回模型中的所有模块。

使用 Simulink.match.allVariants 函数查找所有模块的过滤器函数，而不管该模块是否因变体而处于活动或非活动状态。

find_system(model,'MatchFilter',@Simulink.match.allVariants);

使用编辑时过滤器函数 Simulink.match.legacy.filterOutCodeInactiveVariantSubsystemChoices 在搜索中包括可变子系统的选择项内的模块，这些模块在仿真中处于活动状态并且是生成代码的一部分。有关编辑时过滤器的限制的信息，请参阅 MatchFilter。

find_system(model, ...
 'MatchFilter',@Simulink.match.legacy.filterOutCodeInactiveVariantSubsystemChoices);

使用编辑时过滤器函数 Simulink.match.legacy.filterOutInactiveVariantSubsystemChoices 在搜索中包括可变子系统的活动选择项内的模块。有关编辑时过滤器的限制的信息，请参阅 MatchFilter。

find_system(model, ...
 'MatchFilter',@Simulink.match.legacy.filterOutInactiveVariantSubsystemChoices);

使用 Simulink.match.variantAssemblySubsystems 函数在 slexVariantAssemblySubsystemWithMaskInLabel 模型中查找所有 Variant Assembly Subsystem 模块。

load_system('slexVariantAssemblySubsystemWithMaskInLabel');
find_system('slexVariantAssemblySubsystemWithMaskInLabel','MatchFilter',@Simulink.match.variantAssemblySubsystems);

比较变体模块的匹配过滤器的编译前和编译后行为

此示例使用:

打开实时脚本

此示例比较内置 find_system MatchFilter 函数的编译前和编译后结果，以查找变体模块。这些过滤器有助于查找在仿真中处于活动状态或作为生成代码一部分的变体模块：

Simulink.match.activeVariants
Simulink.match.codeCompileVariants

打开模型 slexVariantSubsystems。该模型配置为使用 Embedded Coder® 生成代码，并使用基于 ERT 的系统目标文件 ert.tlc。

model="slexVariantSubsystems";
open_system(model);

2.将 Controller 模块的 VariantActivationTime 参数设置为 code compile。对于此激活时间，使用 Embedded Coder 生成的代码同时包括活动和非活动变体选择项。

set_param('slexVariantSubsystems/Controller','VariantActivationTime','code compile');

3.对于 Controller 模块的选择项，将 TreatAsAtomicUnit 参数设置为 on。需要执行此步骤以使用 Controller 模块的 code compile 激活时间。

set_param('slexVariantSubsystems/Controller/Linear Controller', 'TreatAsAtomicUnit', 'on');
set_param('slexVariantSubsystems/Controller/Nonlinear Controller', 'TreatAsAtomicUnit', 'on');

模型编译前的 find_system 结果

在编译模型之前使用内置的匹配过滤器将返回模型中的所有模块，而不考虑其变体活动性。

find_system(model,MatchFilter=@Simulink.match.activeVariants)

ans = 25×1 cell
    {'slexVariantSubsystems'                                                   }
    {'slexVariantSubsystems/Controller'                                        }
    {'slexVariantSubsystems/Controller/sensor1'                                }
    {'slexVariantSubsystems/Controller/sensor2'                                }
    {'slexVariantSubsystems/Controller/sensor3'                                }
    {'slexVariantSubsystems/Controller/Linear Controller'                      }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor1'              }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor2'              }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor3'              }
    {'slexVariantSubsystems/Controller/Linear Controller/Add'                  }
    {'slexVariantSubsystems/Controller/Linear Controller/Discrete↵Transfer Fcn'}
    {'slexVariantSubsystems/Controller/Linear Controller/Out1'                 }
    {'slexVariantSubsystems/Controller/Nonlinear Controller'                   }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/sensor1'           }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/sensor2'           }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/sensor3'           }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/1-D Lookup Table'  }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/Add'               }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/Out1'              }
    {'slexVariantSubsystems/Controller/Out1'                                   }
    {'slexVariantSubsystems/Scope'                                             }
    {'slexVariantSubsystems/sine1'                                             }
    {'slexVariantSubsystems/sine2'                                             }
    {'slexVariantSubsystems/sine3'                                             }
    {'slexVariantSubsystems/Out1'                                              }

find_system(model,MatchFilter=@Simulink.match.codeCompileVariants)

ans = 25×1 cell
    {'slexVariantSubsystems'                                                   }
    {'slexVariantSubsystems/Controller'                                        }
    {'slexVariantSubsystems/Controller/sensor1'                                }
    {'slexVariantSubsystems/Controller/sensor2'                                }
    {'slexVariantSubsystems/Controller/sensor3'                                }
    {'slexVariantSubsystems/Controller/Linear Controller'                      }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor1'              }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor2'              }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor3'              }
    {'slexVariantSubsystems/Controller/Linear Controller/Add'                  }
    {'slexVariantSubsystems/Controller/Linear Controller/Discrete↵Transfer Fcn'}
    {'slexVariantSubsystems/Controller/Linear Controller/Out1'                 }
    {'slexVariantSubsystems/Controller/Nonlinear Controller'                   }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/sensor1'           }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/sensor2'           }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/sensor3'           }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/1-D Lookup Table'  }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/Add'               }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/Out1'              }
    {'slexVariantSubsystems/Controller/Out1'                                   }
    {'slexVariantSubsystems/Scope'                                             }
    {'slexVariantSubsystems/sine1'                                             }
    {'slexVariantSubsystems/sine2'                                             }
    {'slexVariantSubsystems/sine3'                                             }
    {'slexVariantSubsystems/Out1'                                              }

模型编译后的 find_system 结果

编译模型。

set_param(model,"SimulationCommand","update");

使用 Simulink.match.activeVariants 过滤器将返回在仿真中处于活动状态的模块。

find_system(model,MatchFilter=@Simulink.match.activeVariants)

ans = 18×1 cell
    {'slexVariantSubsystems'                                                   }
    {'slexVariantSubsystems/Controller'                                        }
    {'slexVariantSubsystems/Controller/sensor1'                                }
    {'slexVariantSubsystems/Controller/sensor2'                                }
    {'slexVariantSubsystems/Controller/sensor3'                                }
    {'slexVariantSubsystems/Controller/Linear Controller'                      }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor1'              }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor2'              }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor3'              }
    {'slexVariantSubsystems/Controller/Linear Controller/Add'                  }
    {'slexVariantSubsystems/Controller/Linear Controller/Discrete↵Transfer Fcn'}
    {'slexVariantSubsystems/Controller/Linear Controller/Out1'                 }
    {'slexVariantSubsystems/Controller/Out1'                                   }
    {'slexVariantSubsystems/Scope'                                             }
    {'slexVariantSubsystems/sine1'                                             }
    {'slexVariantSubsystems/sine2'                                             }
    {'slexVariantSubsystems/sine3'                                             }
    {'slexVariantSubsystems/Out1'                                              }

使用 Simulink.match.codeCompileVariants 过滤器将返回作为生成的 C 代码的一部分的模块。

slexVariantSubsystems([],[],[],"compileForCodegen");
slexVariantSubsystems([],[],[],"term");
find_system("slexVariantSubsystems",MatchFilter=@Simulink.match.codeCompileVariants)

ans = 25×1 cell
    {'slexVariantSubsystems'                                                   }
    {'slexVariantSubsystems/Controller'                                        }
    {'slexVariantSubsystems/Controller/sensor1'                                }
    {'slexVariantSubsystems/Controller/sensor2'                                }
    {'slexVariantSubsystems/Controller/sensor3'                                }
    {'slexVariantSubsystems/Controller/Linear Controller'                      }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor1'              }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor2'              }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor3'              }
    {'slexVariantSubsystems/Controller/Linear Controller/Add'                  }
    {'slexVariantSubsystems/Controller/Linear Controller/Discrete↵Transfer Fcn'}
    {'slexVariantSubsystems/Controller/Linear Controller/Out1'                 }
    {'slexVariantSubsystems/Controller/Nonlinear Controller'                   }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/sensor1'           }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/sensor2'           }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/sensor3'           }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/1-D Lookup Table'  }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/Add'               }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/Out1'              }
    {'slexVariantSubsystems/Controller/Out1'                                   }
    {'slexVariantSubsystems/Scope'                                             }
    {'slexVariantSubsystems/sine1'                                             }
    {'slexVariantSubsystems/sine2'                                             }
    {'slexVariantSubsystems/sine3'                                             }
    {'slexVariantSubsystems/Out1'                                              }

查找所有模块而不考虑模块的活动性

使用 Simulink.match.allVariants() 滤波器查找所有模块的过滤器函数，而不管该模块是否因变体而处于活动或非活动状态。

find_system(model,MatchFilter=@Simulink.match.allVariants)

ans = 25×1 cell
    {'slexVariantSubsystems'                                                   }
    {'slexVariantSubsystems/Controller'                                        }
    {'slexVariantSubsystems/Controller/sensor1'                                }
    {'slexVariantSubsystems/Controller/sensor2'                                }
    {'slexVariantSubsystems/Controller/sensor3'                                }
    {'slexVariantSubsystems/Controller/Linear Controller'                      }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor1'              }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor2'              }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor3'              }
    {'slexVariantSubsystems/Controller/Linear Controller/Add'                  }
    {'slexVariantSubsystems/Controller/Linear Controller/Discrete↵Transfer Fcn'}
    {'slexVariantSubsystems/Controller/Linear Controller/Out1'                 }
    {'slexVariantSubsystems/Controller/Nonlinear Controller'                   }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/sensor1'           }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/sensor2'           }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/sensor3'           }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/1-D Lookup Table'  }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/Add'               }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/Out1'              }
    {'slexVariantSubsystems/Controller/Out1'                                   }
    {'slexVariantSubsystems/Scope'                                             }
    {'slexVariantSubsystems/sine1'                                             }
    {'slexVariantSubsystems/sine2'                                             }
    {'slexVariantSubsystems/sine3'                                             }
    {'slexVariantSubsystems/Out1'                                              }

输入参数

全部折叠

`Model` — 要搜索的模型和子系统
句柄 | 模型名称 | 模块路径

要搜索的模型和子系统。将模型指定为句柄或名称。将子系统指定为对应 Subsystem 模块的模块路径。将句柄格式化为数值标量或数值数组。将名称格式化为字符串、字符串数组、字符向量或字符向量元胞数组。

有关获取句柄和路径的信息，请参阅Get Handles and Paths。

示例: "myModel/mySubsystem"

示例: ["myModel1","myModel2"]

名称-值参数

全部展开

将可选参量对组指定为 Name1=Value1,...,NameN=ValueN，其中 Name 是参量名称，Value 是对应的值。名称-值参量必须出现在其他参量之后，但对各个参量对组的顺序没有要求。

示例: SearchDepth="0",SearchUnderMasks="none",BlockType ="Goto" 在加载的模型（不包括封装子系统）中搜索 Goto 模块。

使用 find_system 函数时，Name=Value 参量可以包括：

搜索条件，例如 CaseSensitive="on"
参数值，例如 BlockType="Gain"

您可以按任意顺序指定搜索条件和按任意顺序指定参数值，但搜索条件必须在参数值之前。

有关模块参数的信息，请参阅以编程方式指定模块参数和属性。

搜索条件

全部展开

`BlockDialogParams` — 在模块参数中搜索指定值
参数名称

搜索模块对话框参数中某个值的选项，指定为字符串或字符向量。此参量必须跟在其他搜索条件参量后。

数据类型: string | character vector

`CaseSensitive` — 考虑文本大小写
`"on"` (默认) | `"off"`

考虑文本大小写的选项，指定为 "on" 或 "off"。

数据类型: string | character vector

`FindAll` — 在搜索中包括信号线、端口和注解
`"off"` (默认) | `"on"`

用于在搜索中包括信号线、端口和注解的选项，指定为 "on" 或 'off'。当此选项设置为 "off" 时，无论您是将 Model 参量指定为完整模型路径名称、模型路径名称元胞数组、句柄还是句柄向量，find_system 函数都会返回句柄向量。

数据类型: string | character vector

`Type` — 搜索特定类型的模型元素
`"block"` (默认) | `"line"` | `"port"` | `"annotation"` | `"block_diagram"`

用于搜索特定类型的模型元素的选项，指定为以下各项之一：

"block"
"line"
"port"
"annotation"
"block_diagram"

要查找信号线、端口或注解，您必须先将 FindAll 的值指定为 "on"，然后您可以选择通过指定 Type 的值来缩小要搜索的模型元素类型的范围。您可以在 FindAll 和 Type 之前、之后和之间指定其他搜索条件选项。例如，要在名为 myModel 的模型中查找注解并在封装下查找，请在 MATLAB^® 命令行窗口中输入此命令。

find_system("myModel",FindAll="on",SearchUnderMasks="all",Type="annotation")

数据类型: string | character vector

`FirstResultOnly` — 只返回第一个结果然后停止搜索
`"off"` (默认) | `"on"`

用于仅返回第一个结果然后停止搜索的选项，指定为 "on" 或 "off"。

数据类型: string | character vector

`SearchInsideSubsystemReferences` — 在引用子系统内部搜索
`"on"` (默认) | `"off"`

用于搜索模型中的引用子系统内部并列出子模块的选项，指定为 "on" 或 "off"。

数据类型: string | character vector

`SearchInsideModelReferences` — 在模型引用内部搜索
`"off"` (默认) | `"on"`

用于在模型中的引用模型内部搜索并列出子模块的选项，指定为 "on" 或 "off"。启用 SearchInsideModelReferences 时，find_system 函数会加载顶层和所有引用模型，并在层次结构的所有模型中进行递归搜索。

数据类型: string | character vector

`SearchInsideLibraryLinks` — 在库链接内部搜索
`"off"` (默认) | `"on"`

用于在库链接内部搜索的选项，指定为 "on" 或 "off"。如果您不指定要搜索的模型，find_system 函数将在结果中包括已加载的库，不管您将 SearchInsideLibraryLinks 设置为 "on" 还是 "off"。您可以将 SearchInsideLibraryLinks 与 SearchUnderMasks 结合使用，以更新子系统中的库链接。请参阅更新子系统中的库链接。

数据类型: string | character vector

`IncludeCommented` — 在搜索中包含带注释的模块
`"off"` (默认) | `"on"`

用于指示在搜索中是否包含带注释的模块的选项，指定为 "on" 或 "off"。

数据类型: string | character vector

`LoadFullyIfNeeded` — 指示在搜索中是否将部分加载的模型完全加载
`"on"` (默认) | `"off"`

用于指示是否将部分加载的模型完全加载的选项，指定为 "on"（表示加载模型）或 "off"（表示禁用加载）。例如，使用此选项可以防止出现加载警告。

数据类型: string | character vector

`SearchUnderMasks` — 在封装内部搜索
`"graphical"` (默认) | `"none"` | `"functional"` | `"all"`

用于指示如何搜索封装子系统的选项，指定为以下各项之一：

"none" - 搜索将跳过封装子系统。
"all" - 搜索包括所有封装子系统。
"functional" - 搜索包括具有图标绘图命令或封装初始化命令但没有参数、描述、帮助字符串和 UI 元素的封装子系统。
"graphical" - 搜索包括只有图标绘图命令而没有工作区、对话框、帮助字符串和 UI 元素的封装子系统。

注意

选项 "none" 取代了以前的选项 "off"。选项 "all" 取代了以前的选项 "on"。

数据类型: string | character vector

`RegExp` — 将搜索表达式视为正则表达式
`"off"` (默认) | `"on"`

用于将搜索表达式视为正则表达式的选项，指定为 "on" 或 "off"。当 RegExp 设置为 "on" 时，搜索将搜索表达式视为正则表达式。有关 MATLAB 正则表达式的详细信息，请参阅正则表达式。

数据类型: string | character vector

`SearchDepth` — 限制搜索路径
正整数

用于将搜索深度限制在指定级别的选项，指定为正整数、字符串或字符向量。例如，指定 0 将仅搜索加载的模型，指定 1 将搜索模型层次结构顶层的模块和子系统，指定 2 将搜索模型层次结构的顶层及其子级，以此类推。默认值为搜索所有级别。

数据类型: string | character vector

`Variants` — 搜索变体
`"ActiveVariants"` (默认) | `"AllVariants"` | `"ActivePlusCodeVariants"`

注意

Variants 参量将被删除。请改用 MatchFilter。有关详细信息，请参阅版本历史记录。

用于搜索变体的选项，指定为以下各项之一：

"ActiveVariants" - 仅搜索 Variant Subsystem 中的活动变体选择项。
"AllVariants" - 搜索 Variant Subsystem 中的所有变体选择项。
"ActivePlusCodeVariants" - 搜索 Variant Subsystem 中的在仿真中处于活动状态并且是生成代码一部分的所有变体选择项。

此搜索约束仅适用于变体控制项模式设置为 expression 或 label 的 Variant Subsystem 模块。将 find_system 函数与 MatchFilter 选项结合使用，可对所有类型的变体模块进行操作。

数据类型: string | character vector

`MatchFilter` — 在搜索中匹配和过滤元素
函数句柄

用于在搜索中匹配和过滤模型元素（如模块、模型、信号线、端口和注解）的选项，指定为函数句柄。使用 MatchFilter 确定在搜索中应包括还是跳过元素。

参量：

允许您使用自定义过滤器函数过滤元素
在过滤器不匹配时避免处理元素
对模块、信号线或注解应用复杂过滤器，以在内部过滤结果

命名函数必须在 MATLAB 程序文件中定义。该函数将模型元素的句柄作为输入，并返回两个输出。

 function [match, prune] = func(element)

输入 element 是正在处理的模型元素的句柄，例如模块句柄。
第一个输出 match 是逻辑值。如果为 false，搜索将跳过该元素。
第二个输出 prune 是可选的逻辑值，仅当模型元素是子系统时适用。默认值为 false。如果此值设置为 true，则搜索中将忽略整个子系统。

有关说明如何创建自定义匹配过滤器函数的示例，请参阅使用自定义 MatchFilter 函数过滤 find_system 搜索。

变体：Simulink^® 提供这些内置的匹配过滤器函数来查找变体模块。

编译后过滤器函数：

Simulink.match.activeVariants - 查找模型编译后在仿真中处于活动状态的模块。
Simulink.match.codeCompileVariants - 查找在模型编译后作为生成代码一部分的模块。
Simulink.match.allVariants - 查找所有模块，无论该模块因变体而处于活动还是非活动状态。
Simulink.match.variantAssemblySubsystems - 查找所有 Variant Assembly Subsystem 模块。

有关说明如何使用这些过滤器的示例，请参阅使用 find_system 和内置的 MatchFilter 函数查找变体模块。

注意

当使用 @Simulink.match.allVariants 匹配过滤器以识别激活时间为更新图的 Variant Subsystem 模块的所有选择项内的模块时，该函数会列出非活动变体选择项，但仅对活动变体选择项执行 LoadFcn 回调。该函数不会为非活动变体选择项执行 LoadFcn 回调，因为它们不影响模型执行。

为了获得正确的结果，在使用 Simulink.match.activeVariants 和 Simulink.match.codeCompileVariants 过滤器之前，您必须编译模型。如果模型未编译，这些过滤器将返回模型中的所有模块。有关比较这些过滤器的编译前和编译后时间结果的示例，请参阅比较变体模块的匹配过滤器的编译前和编译后行为。

Variant Subsystem 模块的编辑时过滤器函数：

Simulink.match.legacy.filterOutCodeInactiveVariantSubsystemChoices - 在搜索中包括可变子系统的选择项内的模块，这些模块在仿真中处于活动状态并且是生成代码的一部分。此函数产生的结果与 Variants 参量的 ActivePlusCodeVariants 选项类似。
Simulink.match.legacy.filterOutInactiveVariantSubsystemChoices - 在搜索中包括可变子系统的活动选择项内的模块。此函数产生的结果与 Variants 参量的 ActiveVariants 选项类似。

编辑时过滤器的限制：

过滤器不使用 CompiledVariantInfo 模块参数中的编译后模块活动性信息。
过滤器仅适用于具有以下模块参数设置的 Variant Subsystem 模块：
- 变体控制项模式设置为表达式或标签
- 将条件传播到可变子系统之外设置为 off
仅在 find_system 函数、find_mdlrefs 函数和 Simulink.FindOptions 对象的上下文中使用时，过滤器才能识别模块句柄是否在 Variant Subsystem 的活动选择项内。

要对所有类型的变体模块进行操作，请在模型编译后使用 Simulink.match.codeCompileVariants 或 Simulink.match.activeVariants 过滤器。

`SegmentType` — 搜索特定类型的信号线段
`"trunk"` | `"branch"`

搜索分支信号线的特定部分的选项，指定为以下项之一：

"trunk" - 连接到输出端口或未连接到信号源的分支
"branch" - 连接到主干的分支

要查找分支信号线的特定部分，您必须先将 FindAll 的值指定为 "on"，然后将 Type 的值指定为 "line"，再指定 SegmentType 的值。您可以在 FindAll、Type 和 SegmentType 选项之前、之后和之间指定其他搜索条件选项。例如，要在名为 myModel 的模型中查找作为主干并在封装内部查找的信号线段，请在 MATLAB 命令行窗口中输入以下命令。

trunkSegments = find_system("myModel",FindAll="on",..
SearchUnderMasks="all",type="line",SegmentType="trunk");

数据类型: string | character vector

输出参量

全部折叠

`Objects` — 匹配对象
句柄 | 模型名称 | 路径

找到的匹配对象，以句柄、名称或路径形式返回。句柄格式化为数值标量或数值数组。名称和路径格式化为字符向量或字符向量元胞数组。

当同时满足以下两个条件时，找到的对象以名称或路径形式返回。

搜索条件选项 FindAll 设置为其默认值 "off"。
您使用名称指定了 Model，或您未指定模型。

当至少满足以下一个条件时，找到的对象将以句柄形式返回。

将 FindAll 的值设置为 "on"。
您使用句柄指定了 Model。

数据类型: double | array of doubles | character vector | cell array of character vectors

版本历史记录

在 R2006a 之前推出

全部展开

R2025a: 查看模型和引用中模块的新参量

您可以使用 LookUnderModelBlocks 选项启用在模型中的模块下搜索。例如，find_system("mymodel",LookUnderModelBlocks=on,BlockType="Constant") 在模型 mymodel 的所有模块和所有引用模型中搜索 Constant 模块。

R2025a: `find_system` 参量已重命名

以下选项已重命名：

LookUnderModelBlocks 已重命名为 SearchInsideModelReferences。
LookInsideSubsystemReference 已重命名为 SearchInsideSubsystemReferences。
LookUnderMasks 已重命名为 SearchUnderMasks。
FollowLinks 已重命名为 SearchInsideLibraryLinks。

以前的名称继续有效。

R2022b: 删除 `Variants` 参量时会发出警告

由于以后的版本中会删除 Variants 参量，因此引入了以下警告：

当您使用不带 Variants 参量的 find_system 函数时，如果该函数在搜索过程中跳过 Variant Subsystem 模块的非活动选择项，则会生成警告。

以包含一个 Variant Subsystem 模块的模型为例，该模型有两个变体选择项 Linear Controller 和 Nonlinear Controller。Nonlinear Controller 模块是活动选择项。

此命令会跳过非活动的 Linear Controller 模块并生成警告。

blocks = find_system('sldemo_variant_subsystems/Controller')

Warning: Using find_system without the 'Variants' argument skips inactive Variant 
Subsystem blocks in the search. This behavior will change in a future release to 
look at all choices of the Variant Subsystem. To find blocks thatare active in 
simulation or code generation, compile the model and use the built-in variant 
filters with the 'MatchFilter' option.

blocks =

  12×1 cell array

    {'sldemo_variant_subsystems/Controller'                                      }
    {'sldemo_variant_subsystems/Controller/sensor1'                              }
    {'sldemo_variant_subsystems/Controller/sensor2'                              }
    {'sldemo_variant_subsystems/Controller/sensor3'                              }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller'                 }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/sensor1'         }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/sensor2'         }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/sensor3'         }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/1-D Lookup Table'}
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/Add'             }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/Out1'            }
    {'sldemo_variant_subsystems/Controller/Out1'                                 }

当您使用 Variants 参量且其值设置为 'AllVariants' 时，该函数会生成警告。

blocks = find_system('sldemo_variant_subsystems/Controller',...
                     'Variants','AllVariants')

Warning: 'Variants' will be removed. Instead of using 'Variants' with value set to
'AllVariants', use 'MatchFilter' with value set to @Simulink.match.allVariants.

blocks =

  19×1 cell array

    {'sldemo_variant_subsystems/Controller'                                        }
    {'sldemo_variant_subsystems/Controller/sensor1'                                }
    {'sldemo_variant_subsystems/Controller/sensor2'                                }
    {'sldemo_variant_subsystems/Controller/sensor3'                                }
    {'sldemo_variant_subsystems/Controller/Linear Controller'                      }
    {'sldemo_variant_subsystems/Controller/Linear Controller/sensor1'              }
    {'sldemo_variant_subsystems/Controller/Linear Controller/sensor2'              }
    {'sldemo_variant_subsystems/Controller/Linear Controller/sensor3'              }
    {'sldemo_variant_subsystems/Controller/Linear Controller/Add'                  }
    {'sldemo_variant_subsystems/Controller/Linear Controller/Discrete↵Transfer Fcn'}
    {'sldemo_variant_subsystems/Controller/Linear Controller/Out1'                 }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller'                   }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/sensor1'           }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/sensor2'           }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/sensor3'           }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/1-D Lookup Table'  }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/Add'               }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/Out1'              }
    {'sldemo_variant_subsystems/Controller/Out1'                                   }

R2022a: 新的内置匹配过滤器可用于查找所有变体模块

您可以使用内置的匹配过滤器 Simulink.match.allVariants 来查找变体模型中的所有模块，而不管该模块由于变体而处于活动状态还是非活动状态。此滤波器是 AllVariants 选项的推荐替代项。

即将删除	推荐的替代项
find_system(model,'Variants', ... 'AllVariants');	find_system(model,'MatchFilter', ... @Simulink.match.allVariants);

R2021a: 在具有变体模块的模型中，`Variants` 和 `MatchFilter` 参量的默认行为已更改

Variants:当您使用 find_system 函数而未指定 Variants 参量时，默认情况下，该函数当前在搜索中仅包括 Variant Subsystem 模块的活动变体选择项。
对于 Variant Source、Variant Sink 或 Variant Subsystem 等其他变体模块，如果将条件传播到可变子系统之外参数设置为 on，该函数将在搜索中包括所有选择项。
以包含一个 Variant Subsystem 的模型为例，该模型有两个变体选择项 Linear Controller 和 Nonlinear Controller。
此命令仅返回模型中的活动 Add 模块。
```
add_blocks = find_system('sldemo_variant_subsystems/Controller',...
'BlockType','Sum')
```
```
add_blocks =

  1×1 cell array

    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/Add'}
```

MatchFilter:当您使用带 MatchFilter 参量的 find_system 函数时，默认情况下，该函数会对活动和非活动变体选择项应用过滤器。

以包含一个 Variant Subsystem 的模型为例，该模型有两个变体选择项 Linear Controller 和 Nonlinear Controller。过滤器函数 findAddBlocks 查找模型中的所有 Add 模块。

 function match = findAddBlocks(handle)
 match = strcmp(get_param(handle, 'Type'), 'block') &&...
 strcmp(get_param(handle, 'BlockType'), 'Sum');
 end

以下命令返回模型中的活动和非活动 Add 模块。

add_blocks = find_system('sldemo_variant_subsystems','MatchFilter',...
@findAddBlocks)

add_blocks =

  2×1 cell array

    {'sldemo_variant_subsystems/Controller/Linear Controller/Add'   }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/Add'}

R2021a: `Variants` 参量将被删除

在以后的版本中，将从 find_system 中删除 Variants 参量。使用 Variants 参量的函数调用会继续工作，但会出现警告。

使用带 Variants 参量的 find_system 函数会产生不一致的搜索结果。find_system 函数在编辑时运行，但要确定模块在具有所有类型的变体模块的模型中是否处于活动状态，您需要编译该模型。

要查找在仿真或代码生成过程中处于活动状态的变体模块，请编译模型并使用带 MatchFilter 参量的 find_system 函数。

下表列出了 Variants 参量的不同值的建议替代项。

即将删除	推荐的替代项
find_system(model,'Variants', ... 'ActiveVariants');	set_param(model,'SimulationCommand','update'); find_system(model,'MatchFilter', ... @Simulink.match.activeVariants);
find_system(model,'Variants', ... 'ActivePlusCodeVariants');	model([], [], [], 'compileForCodegen'); activeBlks= find_system(model,'MatchFilter', ... @Simulink.match.codeCompileVariants); model([], [], [], 'term');

即将删除

推荐的替代项

find_system(model,'Variants', ...
'ActiveVariants');

set_param(model,'SimulationCommand','update');
find_system(model,'MatchFilter', ...
@Simulink.match.activeVariants);

find_system(model,'Variants', ...
'ActivePlusCodeVariants');

model([], [], [], 'compileForCodegen');
activeBlks= find_system(model,'MatchFilter', ...
@Simulink.match.codeCompileVariants);
model([], [], [], 'term');

使用 find_system 函数时，不能同时指定 MatchFilter 和 Variants 参量。

以下命令会生成错误。

find_system(bdroot,'MatchFilter',@Simulink.match.activeVariants,...
    'Variants','ActiveVariants');

R2020b: 在搜索过程中使用 `MatchFilter` 过滤元素

要在搜索过程中匹配和过滤模型元素，您可以定义自定义过滤器函数，并将函数句柄作为值传递给 MatchFilter 名称-值参量。

要查找在仿真中处于活动状态或作为生成代码一部分的变体模块，您可以在编译模型后使用内置的匹配过滤器函数 Simulink.match.activeVariants、Simulink.match.codeCompileVariants 和 Simulink.match.allVariants。

另请参阅

find_system

语法

描述

示例

获取模型中模块的路径

获取模型中模块的句柄

获取子系统中特定类型模块的句柄

获取具有特定参数值的模块的句柄

使用正则表达式获取名称包含关键字的模块的句柄

获取模型中信号线的句柄

获取已加载模型、库和子系统的名称

更新子系统中的库链接

使用自定义 MatchFilter 函数过滤 find_system 搜索

使用 find_system 和内置的 MatchFilter 函数查找变体模块

比较变体模块的匹配过滤器的编译前和编译后行为

输入参数

Model — 要搜索的模型和子系统 句柄 | 模型名称 | 模块路径

名称-值参数

搜索条件

BlockDialogParams — 在模块参数中搜索指定值 参数名称

CaseSensitive — 考虑文本大小写 "on" (默认) | "off"

FindAll — 在搜索中包括信号线、端口和注解 "off" (默认) | "on"

Type — 搜索特定类型的模型元素 "block" (默认) | "line" | "port" | "annotation" | "block_diagram"

FirstResultOnly — 只返回第一个结果然后停止搜索 "off" (默认) | "on"

SearchInsideSubsystemReferences — 在引用子系统内部搜索 "on" (默认) | "off"

SearchInsideModelReferences — 在模型引用内部搜索 "off" (默认) | "on"

SearchInsideLibraryLinks — 在库链接内部搜索 "off" (默认) | "on"

IncludeCommented — 在搜索中包含带注释的模块 "off" (默认) | "on"

LoadFullyIfNeeded — 指示在搜索中是否将部分加载的模型完全加载 "on" (默认) | "off"

SearchUnderMasks — 在封装内部搜索 "graphical" (默认) | "none" | "functional" | "all"

RegExp — 将搜索表达式视为正则表达式 "off" (默认) | "on"

SearchDepth — 限制搜索路径 正整数

Variants — 搜索变体 "ActiveVariants" (默认) | "AllVariants" | "ActivePlusCodeVariants"

MatchFilter — 在搜索中匹配和过滤元素 函数句柄

SegmentType — 搜索特定类型的信号线段 "trunk" | "branch"

输出参量

Objects — 匹配对象 句柄 | 模型名称 | 路径

版本历史记录

R2025a: 查看模型和引用中模块的新参量

R2025a: find_system 参量已重命名

R2022b: 删除 Variants 参量时会发出警告

R2022a: 新的内置匹配过滤器可用于查找所有变体模块

R2021a: 在具有变体模块的模型中，Variants 和 MatchFilter 参量的默认行为已更改

R2021a: Variants 参量将被删除

R2020b: 在搜索过程中使用 MatchFilter 过滤元素

另请参阅

主题

使用自定义 `MatchFilter` 函数过滤 `find_system` 搜索

使用 `find_system` 和内置的 `MatchFilter` 函数查找变体模块

`Model` — 要搜索的模型和子系统
句柄 | 模型名称 | 模块路径

`BlockDialogParams` — 在模块参数中搜索指定值
参数名称

`CaseSensitive` — 考虑文本大小写
`"on"` (默认) | `"off"`

`FindAll` — 在搜索中包括信号线、端口和注解
`"off"` (默认) | `"on"`

`Type` — 搜索特定类型的模型元素
`"block"` (默认) | `"line"` | `"port"` | `"annotation"` | `"block_diagram"`

`FirstResultOnly` — 只返回第一个结果然后停止搜索
`"off"` (默认) | `"on"`

`SearchInsideSubsystemReferences` — 在引用子系统内部搜索
`"on"` (默认) | `"off"`

`SearchInsideModelReferences` — 在模型引用内部搜索
`"off"` (默认) | `"on"`

`SearchInsideLibraryLinks` — 在库链接内部搜索
`"off"` (默认) | `"on"`

`IncludeCommented` — 在搜索中包含带注释的模块
`"off"` (默认) | `"on"`

`LoadFullyIfNeeded` — 指示在搜索中是否将部分加载的模型完全加载
`"on"` (默认) | `"off"`

`SearchUnderMasks` — 在封装内部搜索
`"graphical"` (默认) | `"none"` | `"functional"` | `"all"`

`RegExp` — 将搜索表达式视为正则表达式
`"off"` (默认) | `"on"`

`SearchDepth` — 限制搜索路径
正整数

`Variants` — 搜索变体
`"ActiveVariants"` (默认) | `"AllVariants"` | `"ActivePlusCodeVariants"`

`MatchFilter` — 在搜索中匹配和过滤元素
函数句柄

`SegmentType` — 搜索特定类型的信号线段
`"trunk"` | `"branch"`

`Objects` — 匹配对象
句柄 | 模型名称 | 路径

R2025a: `find_system` 参量已重命名

R2022b: 删除 `Variants` 参量时会发出警告

R2021a: 在具有变体模块的模型中，`Variants` 和 `MatchFilter` 参量的默认行为已更改

R2021a: `Variants` 参量将被删除

R2020b: 在搜索过程中使用 `MatchFilter` 过滤元素