Simulink® provides several techniques for combining signals into a composite signal. For a comparison of techniques, see Types of Composite Signals.
An array of nonvirtual buses is an array whose elements are buses. Each
Bus object has the same signal name, hierarchy, and attributes
for its bus elements.
An example of using an array of buses is to model a multi-channel system, such as
a communications system. You can model all the channels using the same
Bus object, although each of the channels could have a
To use an array of buses:
Bus object as a data type (see Specify a Bus Object Data Type).
Specify dimensions for the bus and bus elements.
For an example of a model that uses an array of buses, open the
model. In this example, the nonvirtual bus input signals connect to a Vector
Concatenate or Matrix Concatenate block that creates an
array of buses. Here is the diagram after you update it:
The model uses the array of buses with:
An Assignment block, to assign a bus in the array
A For Each Subsystem block, to perform iterative processing over each bus in the array
A Memory block, to output the array of buses input from the previous time step
Use an array of buses to:
Represent structured data compactly.
Reduce model complexity.
Reduce maintenance by centralizing algorithms used for processing multiple buses.
Streamline iterative processing of multiple buses of the same type, for example, by using a For Each Subsystem with the array of buses.
Simplify changing the number of buses, without your having to restructure the rest of the model or make updates in multiple places in the model.
Use built-in blocks, such as the Assignment or Selector blocks, to manipulate arrays of buses just like arrays of any other type. Using an array of buses avoids the need for you to create custom S-functions to manage packing and unpacking structure signals.
Use the combined bus data across subsystem boundaries, model reference boundaries, and into or out of a MATLAB Function block.
Keep all the logic in the Simulink model, rather than splitting the logic between C code and the Simulink model. This approach supports integrated consistency and correctness checking, maintaining metadata in the model, and avoids the need to manage model components in two different environments.
Generate code that has an array of C structures, which you can integrate
with legacy C code that uses arrays of structures. This approach simplifies
indexing into an array for Simulink computations, using a
for loop on indexed
For information about the kinds of buses that you can combine into an array of buses, see Bus Requirements.
To define an array of buses, use a Concatenate block. The table describes the array of buses input requirements and output for each of the Vector Concatenate and the Matrix Concatenate versions of the Concatenate block.
|Block||Bus Signal Input Requirement||Output|
Vectors, row vectors, or columns vectors
If any of the inputs are row or column vectors, output is a row or column vector.
Signals of any dimensionality (scalars, vectors, and matrices)
Trailing dimensions are assumed to be 1 for lower dimensionality inputs.
Concatenation is on the dimension that you specify with the Concatenate dimension parameter.
Do not use a Mux block or a Bus Creator block to define an array of buses. Instead, use a Bus Creator block to create scalar buses.
Bus object for all of the buses that
you want to combine into an array of buses. For information about defining
Bus objects, see Specify Bus Properties with Simulink.Bus Objects.
sldemo_bus_arrays model defines an
Bus object, which both of the Bus Creator blocks use for
the input buses (
Scalar Bus) for the array of
sldemo_bus_arrays_busobject model uses a Vector
Concatenate block, because the inputs are scalars.
Set the Number of inputs parameter to be the number of buses that you want to be in the array of buses.
The block icon displays the number of input ports that you specify.
Set the Mode parameter to match the type of the input bus data.
sldemo_bus_arrays model, the input bus data is
scalar, so the Mode setting is
If you use a Matrix Concatenation block, set the Concatenate dimension parameter to specify the output dimension along which to concatenate the input arrays. Enter one of the following values:
1 — concatenate input arrays
2 — concatenate input arrays
A higher dimension than 2 — perform multidimensional concatenation on the inputs
Connect to the Concatenate block all the buses that you want to be in the array of buses.
You can use a Constant block to compactly represent multiple constant-valued signals as an array of buses. You can use this technique to reduce the number of signal lines in a model and the number of variables that the model uses, especially when the model repeats an algorithm with different parameter values.
To generate a constant-valued array of buses, use an array of MATLAB® structures in a Constant block. The block output is an array of buses, and each field in the array of structures provides the simulation value for the corresponding signal element.
You can also use an array of structures to specify the
property of a
Simulink.Parameter object, and use
the parameter object in a Constant block.
Open the example model
const_param_struct appear in the base workspace.
const_param_struct contains a structure
whose field names match the elements of the bus type that
Update the diagram to view the signal line widths.
The output of the Constant block is a single scalar bus
ParamBus. The structure variable
const_param_struct specifies the constant value
in the block.
At the command prompt, create an array of two structures by copying
const_param_struct. Customize the field
values by indexing into the individual structures in the array.
const_struct_array =... [const_param_struct const_param_struct]; const_struct_array(2).Offset = 158; const_struct_array(2).Gain = 3.83; const_struct_array(2).Threshold = 1039.77
const_struct_array = 1x2 struct array with fields: Offset Gain Threshold
In the Constant block dialog box, set
Constant value to
Add two Selector blocks to the model, and connect the Constant block as shown.
In the Selector block dialog box, set Index to
1 and Input port size to
In the Selector1 block dialog box, set Index to
2 and Input port size to
Copy the block algorithm in the model, and connect the blocks as shown.
Update the diagram. The signal line width and style indicate that the output of the Constant block is an array of buses. The Selector blocks each extract one of the buses in the array.
Each copy of the algorithm uses the constant values provided by the
corresponding structure in the variable
To create an array of structures for a bus that uses a large hierarchy of signal
elements, consider using the function
You can also use this technique to create an array of structures if you do not have
a scalar structure that you can copy.