Classic call interface

(To be removed) For models created before R2012a and configured with GRT system target file, generated model function calls that are compatible with main program module

Model Configuration Pane: Code Generation / Interface

The Classic call interface parameter will be removed in a future release. To use the call interface that is common to GRT- and ERT-based system target files, clear this parameter, which is the default setting. (since R2012a) For information on updating a model configuration or migrating a custom GRT-based system target file to use the unified call interface, see Version History.

Description

The Classic call interface parameter specifies whether generated model function calls for models created before R2012a and configured with a GRT system target file are compatible with the main generated program module.

The setting of this parameter enables or disables the Single output/update function parameter. Clearing the parameter enables (but does not select) Single output/update function. Selecting this parameter disables Single output/update function.

This parameter is not supported when:

You use data type replacement.
The System target file parameter is set to an ERT-based system target file and the model is configured to use a service code interface.

Dependencies

To enable this parameter:

Set the Code interface packaging parameter to Non-reusable function or Reusable function.
Clear the Subsystem block parameter Function with separate data.

Settings

Off (default) | On

On

For models created before R2012a and configured with a GRT-based system target file, generates model function calls that are compatible with the main program module (grt_main.c or grt_main.cpp).

This parameter provides a quick way to use code generated in the current release with a GRT-based custom system target file that has a main program module based on a pre-R2012a grt_main.c or grt_main.cpp file.

Off

Disables the classic call interface.

Recommended Settings

Application	Setting
Debugging	No impact
Traceability	Off
Efficiency	Off (execution, ROM), No impact (RAM)
Safety precaution	No recommendation

Programmatic Use

Parameter: GRTInterface

Type: character vector

Value: 'on' | 'off'

Default: 'off' (except 'on' for GRT models created before R2012a)

Version History

Introduced before R2006a

expand all

R2024a: To be removed

The Classic call interface (GRTInterface) parameter will be removed in a future release. In R2012a, the call interface for generated C and C++ entry-point functions for models configured with GRT- and ERT-based system target files was unified and simplified. In the same release, the Classic call interface parameter was introduced for preserving the original GRT-based call interface.

This table compares the classic and the unified call interfaces for generated entry-point functions.

Comparison of Classic and Unified Call Interfaces

Classic Call Interface	Unified Call Interface
void MdlInitializeSizes(void); void MdlInitializeSampleTimes(void); void MdlStart(void); void MdlOutputs(Int_T tid); void MdlUpdate(Int_T tid); void MdlTerminate(void);	void model_initialize(void); void model_step; /* single-tasking / void model_step(tid); / multitasking */ void model_reset(void); void model_terminate(void);

Classic Call Interface

Unified Call Interface

void MdlInitializeSizes(void);
void MdlInitializeSampleTimes(void);
void MdlStart(void);
void MdlOutputs(Int_T tid);
void MdlUpdate(Int_T tid);
void MdlTerminate(void);

void model_initialize(void);
void model_step;      /* single-tasking */
void model_step(tid); /* multitasking */
void model_reset(void); 
void model_terminate(void);

To generate entry-point functions that use the unified call interface, clear Classic call interface. Then, generate code from the model and inspect the call interface code in the generated example main program.

To migrate a custom GRT-based system target file to use the unified call interface, modify your custom system target file to remove the lines of code that declare it or disable the classic call interface. The steps to remove or modify the support depends on how the support is declared. The support might be declared directly in the system target file or in a callback function that is declared in the RTW_OPTION section of the system target file in the SelectCallback field of the rtwgensettings structure.

Direct declaration
A direct declaration looks like this:
```
rtwgensettings.SelectCallback = 'slConfigUISetVal(hDlg,hSrc,...
     ''GRTInterface'',''on'');';
```
Remove the statement or change ''on'' to ''off''.
Declared callback function
The declaration of a callback function in the rtwgensettings structure looks like this, where enableClassicCallInterface is the name of a SelectCallback function that sets the parameter GRTInterface.
```
rtwgensettings.SelectCallback = 'enableClassicCallInterface(hDlg,hSrc)';
```
Remove the declaration or update the callback function to disable the classic call interface. These statements in callback function enableClassicCallInterface disable the classic call interface:
```
slConfigUISetVal(hDlg, hSrc, 'GRTInterface', 'off');
slConfigUISetEnabled(hDlg, hSrc, 'GRTInterface', true);
```

You might also need to modify your static main program. For example, you might need to:

Replace calls to entry-point functions MdlInitializeSizes, MdlInitializeSampleTimes, and MdlStart with a call to model_initialize.
Replace calls to entry-point functions MdlOutputs and ModelUpdates with calls to model_step or model_step(tid). This aligns with the result of selecting the model configuration parameter Single output/update function.
Replace a call to entry-point function MdlTerminate with a call to model_terminate.

For more information about entry-point functions generated for the unified call interface, see model_initialize, model_reset, model_step, and model_terminate. For more information about updating a system target file, see Customize System Target Files.