Truth tables implement combinatorial logic design in a concise, tabular format. Truth
tables are supported only in Stateflow^{®} blocks in a Simulink^{®} model. Typical applications for truth tables include decision making for:

Fault detection and management

Mode switching

You can add a Truth Table block directly to your Simulink model. You can also define a truth table function in a Stateflow chart, state, or subchart. The location of the function determines the set of states and transitions that can call the function.

If you want to call the function only within one state or subchart and its substates, put your truth table function in that state or subchart. That function overrides any other functions of the same name in the parents and ancestors of that state or subchart.

If you want to call the function anywhere in that chart, put your truth table function at the chart level.

If you want to call the function from any chart in your model, put your truth table at the chart level and enable exporting of chart-level functions. For more information, see Export Stateflow Functions for Reuse.

For example, this truth table function has the name `ttable`

. It takes
three arguments (`x`

, `y`

, and `z`

) and
returns one output value (`r`

).

The function consists of this arrangement of conditions, decisions, and actions.

Condition | Decision 1 | Decision 2 | Decision 3 | Default Decision |
---|---|---|---|---|

`x == 1` | T | F | F | - |

`y == 1` | F | T | F | - |

`z == 1` | F | F | T | - |

| `r = 1` | `r = 2` | `r = 3` | `r = 4` |

Each of the conditions entered in the **Condition** column must evaluate
to true (nonzero value) or false (zero value). Outcomes for each condition are specified as T
(true), F (false), or - (true or false). Each of the decision columns combines an outcome for
each condition with a logical AND into a compound condition, which is referred to as a
decision.

You evaluate a truth table one decision at a time, starting with **Decision
1**. The **Default Decision** covers all possible remaining
decisions. If one of the decisions is true, you perform its action, and then the truth table
execution is complete.

For example, if conditions `x == 1`

and `y == 1`

are
false and condition `z == 1`

is true, then **Decision 3** is
true and the variable `r`

is set equal to 3. The remaining decisions are not
tested and evaluation of the truth table is finished. If the first three decisions are false,
then the **Default Decision** is automatically true and its action
(`r=4`

) is executed. This table lists pseudocode corresponding to the
evaluation of this truth table example.

Pseudocode | Description |
---|---|

if ((x == 1) & !(y == 1) & !(z == 1)) r = 1; | If |

elseif (!(x == 1) & (y == 1) & !(z == 1)) r = 2; | If |

elseif (!(x == 1) & !(y == 1) & (z == 1)) r = 3; | If |

else r = 4; endif | If all other decisions are false, then |

In the object palette, click the truth table function icon . Move your pointer to the location for the new truth table function in your chart.

Enter the signature label for the function, as described in Declare Function Arguments and Return Values.

Program the truth table function. For more information, see Program a Truth Table.

In the Model Explorer, expand the chart object and select the truth table function. The arguments and return values of the function signature appear as data items that belong to your function. Arguments have the scope

`Input`

. Return values have the scope`Output`

.In the Data properties dialog box for each argument and return value, specify the data properties, as described in Set Data Properties.

Create any additional data items required by your function. For more information, see Add Data Through the Model Explorer.

Your function can access its own data or data belonging to parent states or the chart. The data items in the function can have one of these scopes:

`Local`

— Local data persists from one function call to the next function call. Valid for C charts only.`Constant`

— Constant data retains its initial value through all function calls.`Parameter`

— Parameter data retains its initial value through all function calls.`Temporary`

— Temporary data initializes at the start of every function call. Valid for C charts only.

In charts that use C as the action language, define temporary data when you want to use
data that is only valid while a function executes. For example, you can designate a loop
counter to have `Temporary`

scope if the counter value
does not need to persist after the function completes.

In charts that use MATLAB^{®} as the action language, you do not need to define temporary function data. If
you use an undefined variable, Stateflow creates a temporary variable. The variable is available to the rest of the
function.

You can initialize your function data (other than arguments and return values) from the MATLAB workspace. For more information, see Initialize Data from the MATLAB Base Workspace.

The function signature label specifies a name for your function and the formal names for its arguments and return values. A signature label has this syntax:

[return_val1,return_val2,...] =function_name(arg1,arg2,...)

You can use the same variable name for both arguments and return values. For example, a
function with this signature label uses the variables `y1`

and
`y2`

as both inputs and
outputs:

[y1, y2, y3] = f(y1, u, y2)

`y1`

and `y2`

are
passed by reference (as pointers), and `u`

is passed by value. Passing
inputs by reference reduces the number of times that the generated code copies intermediate
data, resulting in more optimal code.You can call truth table functions from the actions of any state or transition. You can also call truth table functions from other functions. If you export a truth table function, you can call it from any chart in the model.

The syntax for a call to a truth table function is the same as the function signature, with actual arguments replacing the formal ones specified in a signature. If the data types of an actual and formal argument differ, a function casts the actual argument to the type of the formal argument.

If the formal arguments of a function signature are scalars, verify that inputs and outputs of function calls follow the rules of scalar expansion. For more information, see How Scalar Expansion Works for Functions.

You can set general properties for your truth table function through its properties
dialog box. To open the function properties dialog box, right-click the truth table function
box and select **Properties** from the context menu.

Function name. Click the function name link to bring your function to the foreground in its native chart.

Controls the inlining of your function in generated code:

`Auto`

— Determines whether to inline your function based on an internal calculation.`Inline`

— Inlines your function if you do not export it to other charts and it is not part of a recursion. (A recursion exists if your function calls itself directly or indirectly through another function call.)`Function`

— Does not inline your function.

Signature label for your function. For more information, see Declare Function Arguments and Return Values.

Controls the level of diagnostics for underspecification in your truth table function. For more information, see Correct Overspecified and Underspecified Truth Tables.

Controls the level of diagnostics for overspecification in your truth table function. For more information, see Correct Overspecified and Underspecified Truth Tables.

Controls the action language for your Stateflow truth table function. Choose between MATLAB or C. For more information, see Language Options for Stateflow Truth Tables.

Function description. You can enter brief descriptions of functions in the hierarchy.

Link to online documentation for the function. You can enter a web URL address or a
MATLAB command that displays documentation in a suitable online format, such as an
HTML file or text in the MATLAB Command Window. When you click the **Document
link** hyperlink, Stateflow displays the documentation.