To apply generated code source and header files from the build process, it is helpful to understand the files that the build process generates and the conditions that control file generation. This information provides access to generated code resources, such as:
Public interface to the model entry points
Enumerated types corresponding to built-in data types
Data structures that describe the model signals, states, and parameters
The code generator creates
during the code generation and build process. You can customize the file names for generated
header, source, and data files. For more information, see Customize Generated File Names. The code generator creates additional folders and
dependency files to support shared utilities and model references. For more information about
the folders that the build process creates, see Manage Build Process Folders. For an example that shows how to use a project to
manage build process folders, see Generate Code and Simulate Models in a Project.
Depending on model architectures and code generation options, the build process for a GRT-based system target file can produce files that the build process does not generate for an ERT-based system target file. Also, for ERT-based system target files, the build process packages generated files differently than for GRT-based system target files. See Manage File Packaging of Generated Code Modules.
By default, the build process deletes foreign (not generated) source files in the build folder. It is possible to preserve foreign source files in the build folder by following the guidelines in Preserve External Code Files in Build Folder.
The table describes the principal generated files. Within the generated file names shown
in the table, the
model represents the name of the model for which
you are generating code. The
subsystem represents the name of a
subsystem within the model. When you select the Create code generation
report parameter, the code generator produces a set of HTML files. There is one
HTML file for each source file plus a
_contents.html index file in the
html subfolder within your build folder. The source and header files in
the table have dependency relationships. For descriptions of other file dependencies, see
Manage Build Process File Dependencies and Add Build Process Dependencies.
Defines an enumerated type corresponding to built-in data types.
A model build generates this file when one or more of these conditions apply:
Lists additional sources to include in the compilation.
Contains Windows® batch file commands that set the compiler environment and invoke the
For more information about using this file, see model.bat.
Corresponds to the model file.
The Target Language Compiler generates this C or C++ source code file. The file contains:
Executable program file.
A model build generates this file
unless you explicitly specify that the code generator produce code only. The build
generates the executable in the current folder (not the build folder) under control
Defines model data structures and a public interface to the model entry
points and data structures. Provides an interface to the real-time model data
For more information, see model.h.
Generated makefile that controls compiling and linking the generated code
into the final binary file by the
If you set the
Represents the compiled model.
By default, the build process deletes this ASCII file when the build process is complete. You can choose to retain the file for inspection.
(optional files) Contain data structures that describe the model signals, states, and parameters without using external mode.
For more information, see Exchange Data Between Generated and External Code Using C API.
Contains (if conditionally generated) declarations for the parameters data structure and the constant block I/O data structure, and zero representations for structure data types that the model uses.
A model build generates this
file when the model uses these data structures. The
(optional file) Declares structures that contain data type and data type transition information for generated model data structures for supporting external mode.
The generated source files from the model build
include this file. When you interface external code with generated code from a
For more information, see Manage Build Process File Dependencies.
Contains type definitions for timing bridges.
A model build generates this file for a referenced model or a model containing model reference blocks.
(optional file) Contains MATLAB® language commands that external mode uses to initialize the external mode connection.
Provides forward declarations for the real-time model data structure and the parameters data structure.
The generated header files from the model build include this file. Function declarations of reusable functions can use these structures.
Contains type definitions for multiple-word wide data types and their word-size chunks. If your code uses multiword data types, include this header file.
Declares and initializes global nonfinite values for
A model build generates these files when one or more of these conditions apply:
The build process
does not create these modules at code generation time. The modules include
Provides the essential type definitions,
For ERT-based system target files that do
not generate a GRT interface and do not have noninlined S-functions,
The build process generates these files to help
Contains type definitions for special mathematical constants (such as π and
e) and defines the
A model build generates this file when the generated code requires a mathematical constant definition or when the function body does not access a required model function argument.
(optional files) Provide functions that the noninlined S-functions use in a model.
The noninlined S-functions use functions
(optional file) Contains C source code for each noninlined nonvirtual subsystem or copy the code when the subsystem is configured to place code in a separate file.
(optional file) Contains exported symbols for noninlined nonvirtual subsystems.
This file contains Windows batch file commands that set the compiler environment and invoke the
If you are using the toolchain approach for the build process, you also can use this
batch file to extract information from the generated makefile,
. The information includes macro
definitions and values that appear in the makefile, such as
compiler flags) and
CPP_FLAGS (C++ compiler flags). With the folder
selected as the current
working folder, in the Command Window, type:
>> system('model.bat info')
On UNIX and Macintosh platforms, the code generator does not create the
file. To extract information for
toolchain approach builds from the generated makefile on these systems, in the Command
>> system('gmake -f model.mk info')
The header file
data structures and a public interface to the model entry points and data structures. This
header file also provides an interface to the real-time model data structure
) by using access macros. If your
code interfaces to model functions or model data structures, include
Exported global signals
extern int32_T INPUT; /* '<Root>/In' */
Global structure definitions
/* Block parameters (auto storage) */ extern Parameters_mymodel mymodel_P;
Real-time model (RTM) macro definitions
#ifndef rtmGetSampleTime # define rtmGetSampleTime(rtm, idx) ((rtm)->Timing.sampleTimes[idx]) #endif
Model entry point functions (ERT example)
extern void mymodel_initialize(void); extern void mymodel_step(void); extern void mymodel_terminate(void);
.cpp) file includes
. If the model build generates the
.cpp) file from a TLC script, the TLC
source can include
main.c is a static source file, you can use the fixed header file
rtmodel.h. This file includes the
#include "model.h" /* If main.c is generated */
#include "rtmodel.h" /* If static main.c is used */
Other external source files can require to include
to interface to model data, for
example exported global parameters or signals. The
file itself can have additional
header dependencies due to requirements of generated code. See System Header Files and Code Generator Header Files.
To reduce dependencies and reduce the number of included header files, see Manage Build Process File Dependencies.
The header file
rtwtypes.h defines data types, structures, and macros
required by the generated code. You include
rtwtypes.h for GRT and ERT
system target files, instead of including
Often, the generated code requires that integer operations overflow or underflow at
specific values. For example, when the code expects a 16-bit integer, the code does not
accept an 8-bit or a 32-bit integer type. The C language does not set a standard for the
number of bits in types such as
int, and others.
So, there is no universally accepted data type in C to use
To accommodate this feature of the C language, the generated code uses sized integer
types, such as
uint32_T, and others, which are
not standard C types. In
rtwtypes.h, the generated code maps these
sized-integer types to the corresponding C keyword base type using information in the
Hardware Implementation pane of the configuration
The code generator produces the optimized version of
ERT-based system target files when these conditions apply:
Configuration Parameters > Code Generation > Interface > Advanced parameters > Classic call interface is not selected.
The model does not contain noninlined S-functions.
rtwtypes.h. If you include it for GRT system target files,
for example, it is easier to use your code with ERT-based system target files.
For GRT and ERT system target files, the location of
depends on whether the build process uses the shared utilities
location. If it uses a shared location, the code generator places
rtwtypes.h in the build folder
See Specify Generated Code Interfaces.
Source files include the
rtwtypes.h header file when the source files
use code generator type names or other code generator definitions. A typical example is for
files that declare variables by using a code generator data type, for example,
A source file that the code generator and an S-function use can use the preprocessor
MATLAB_MEX_FILE. The macro definition comes from the
#ifdef MATLAB_MEX_FILE #include "tmwtypes.h" #else #include "rtwtypes.h" #endif
A source file for the code generator
.cpp) file includes
rtwtypes.h without preprocessor
Custom source files that the Target Language Compiler generates can also emit these
include statements into their generated file.