Configure Data Stores for C Code Generation - MATLAB & Simulink (original) (raw)

Data stores enable subsystems and referenced models to share data without using I/O ports to pass the data from level to level (see Data Store Basics andData Stores in Generated Code). Types of data stores include the types listed in this table.

When you open a model in the Embedded Coder app, local and shared local data stores appear in the Code Mappings editor, where you can configure the data stores for code generation. If a model uses global data stores, you can view them in the Code Mappings editor by clicking the Refresh link that appears to the right of the data store name. That link initiates an update diagram and adds global data stores that the model uses in the editor view.

Configure data stores to:

• Make data accessible for interaction while the generated code executes.
• Control where the code generator places data in memory.
• Improve readability and traceability of generated code.

For code generation, examples show how to configure a data store for model ConfigurationInterface. You can configure code mappings by using the Code Mappings Editor – C or code mappings API (coder.mapping.api.CodeMapping).

Choose Customization Options for Data Stores

By default, local data stores in a model appear in generated code as fields of a global data structure named _`model`__DW. Shared local data stores appear as a field of global data structure_`model`__SharedDSM. Based on your code interface requirements, decide whether to customize code generation of data stores. If you do not configure customizations, the code generator determines whether to eliminate or change the representation of data stores in generated code for optimization purposes. If you configure customizations, decide:

• Whether to set up a default configuration
  If a model includes a significant number (for example, more than 10) of data stores for a given category that must be accessible during program execution, it is more efficient to configure the data stores with a default setting, and then override that setting for special cases. If the model includes a few data stores for a given category that have unique source, naming, or placement requirements, consider configuring the data stores individually.
• How to declare and handle model data stores in the generated code
  • As separate global variables
  • To read from data stores as global variables defined in external code
  • As calls to access functions. Requires Embedded Coder®
    For more information about these options, see Control Data and Function Interface in Generated Code.

Other considerations for model parameters include whether to:

• Name data stores in the generated code by using data store names in the model or by using unique code identifiers.
• Include the static type qualifier in global variable definitions and declarations, for example, to prevent name clashes. Requires Embedded Coder. See Prevent Name Clashes by Configuring Data Item as static.
• Include the volatile type qualifier in global variable definitions and declarations. Requires Embedded Coder. See Protect Global Data with const and volatile Type Qualifiers.
• Generate a global data structure with a name that you specify. Requires Embedded Coder. See Organize Data into Structures in Generated Code.
• Place data stores in a specific area of memory. Requires Embedded Coder. See Control Data and Function Placement in Memory by Inserting Pragmas.

For a list of interface requirements that are relevant to data stores with corresponding storage classes and storage class properties, see Choose Storage Class and Storage Class Properties for Data Stores.

For example model ConfigurationInterface, data store requirements are:

• Represent local data stores as separate global variables defined and declared with the static type qualifier.
• Represent shared local data stores as separate global variables defined and declared with the volatile type qualifier.
• Apply prefix ds_ to names of variables that represent data stores.

For this example, you set the default representation for local data stores in the generated code as global variables that have the static type qualifier and shared local data stores as global variables that have thevolatile type qualifier. Then, you configure the local data store in the model to use the default storage class and a unique code identifier that includes the required prefix ds_. The code identifier capability enables you to specify code generation identifiers without having to modify the model design.

Configure Default Code Generation Settings for Data Stores

Default code generation settings for data stores can reduce the effort of preparing a model for code generation, especially if a model has a significant number of data stores that you want to gain access to while the generated code executes. Choose configuration settings once, and the code generator applies those settings to data stores across the model. Simulink® stores the default configuration as part of the model.

Consider configuring default code generation settings for model data stores if your model uses multiple data stores for a given category that do not have unique requirements or use a shared Embedded Coder Dictionary.

This example shows how to use the Code Mappings Editor – C to configure default settings for data stores. Use the Code Mappings editor to set the default storage class for local and shared local data stores in model ConfigurationInterface to FileScope and Volatile, respectively. With those storage class settings, the code generator represents the data stores in the generated code as global variables that have thestatic and volatile type qualifiers.

1. Open model ConfigurationInterface. Save a copy of the model to a writable location.
   
2. Open the Embedded Coder app.
3. In the C Code tab, select > .
4. Configure default code mappings for local data stores. In the Code Mappings editor, on the Data Defaults tab, expand theSignals node. Select category Signals, states, and internal data. Set the storage class to FileScope.
   
5. Configure default code mappings for shared local data stores. Select categoryShared local data stores. Set the storage class toVolatile.
6. Save the model.

Configure Code Generation for Individual Data Stores

You can configure individual data stores for code generation. For example, if a model has two data stores of the same category that have unique code generation requirements, configure the data stores individually. Or, if you configure default settings for a category of data stores, you can override those settings for specific data stores.

If your model meets at least one of these criteria, consider configuring code generation settings for data stores individually:

• Uses multiple data stores of the same category that have unique source, naming, or placement requirements.
• Uses a few data stores of the same category.
• Has a default configuration for a category of data stores and you need to override the configuration for some specific states.

This example shows how to use the Code Mappings editor to apply your default storage class setting to the Data Store Memory block mode in model ConfigurationInterface. The example also shows how configure a code identifier for that data store.

1. If you have not already done so, complete the steps in Configure Default Code Generation Settings for Data Stores.
2. In the Code Mappings editor, click the Data Stores tab. Expand Local Data Stores. The storage class for data storemode is set to Auto, which means that the code generator might eliminate or change the representation of relevant code for optimization purposes. If optimizations are not possible, the code generator applies the model default configuration. For this example, the model default configuration specifies the storage class Volatile.
   • To avoid optimizations and force the code generator to use the default configuration, set the storage class to Model default.
   • To override the default configuration, specify the storage class that meets the code generation requirements for that data store.
3. In the Code Mappings editor, select local data store mode. Set the storage class to Model default: Volatile.
4. Configure the code identifier for the data store with a name that includes the prefix ds_. In the Code Mappings editor, select shared local data store mode. Click the icon and set the storage class propertyIdentifier to ds_mode.
   
5. Save the model.
6. Generate and view the code. For example, in ConfigurationInterface.c, find the data definitions for the data store.
   static boolean_T ds_mode;
   Find where the state data is used in the step entry-point function.
   .
   .
   .
   ds_mode = ((input1 > ConfigurationInterface_UPPER) || (input1 <
   ConfigurationInterface_LOWER));

.
.
.
if (ds_mode) {
output = (real_T)mp_K1 * dout_Table1;
} else {
output = dstate_X;
}
.
.
.

Configure Code Generation Settings for Data Stores Programmatically

To automate configuration of data stores for code generation, use the programming interface for code mappings. For example, when creating custom block libraries or part of an application test environment, use the programming interface to automate data configuration.

This example shows how to use the programming interface to configure data stores for model ConfigurationInterface. Set the default representation of local and shared local data stores in the generated code as global variables that have the static andvolatile type qualifier, respectively. Configure theData Store Memory block mode to use the default storage class and a unique code identifier that includes the required prefixds_.

1. Open the example model.
   openExample("ConfigurationInterface")
2. Create object cm by calling functioncoder.mapping.api.get. The object stores the dataand function code generation configuration for model ConfigurationInterface.
   cm = coder.mapping.api.get("ConfigurationInterface");
3. Configure default settings for local data stores by calling functionsetDataDefault. For the arguments, specify these values:
   • The object returned bycoder.mapping.api.get
   • InternalData for the default category
   • Property name StorageClass with property valueFileScope
     setDataDefault(cm,"InternalData","StorageClass","FileScope");
4. Configure default settings for shared local data stores by calling functionsetDataDefault. Specify these values for arguments:
   • The object returned bycoder.mapping.api.get.
   • SharedLocalDataStore for the default category.
   • Property name StorageClass with property valueVolatile.
     setDataDefault(cm,"SharedLocalDataStore","StorageClass","Volatile");
5. Verify your default configuration settings for local and shared local data stores. Issue a call to getDataDefault that specifies the object returned by coder.mapping.api.get, categoryInternalData, and the propertyStorageClass. In a second call togetDataDefault, replace the category withSharedLocalDataStore.
   getDataDefault(cm,"Internal","StorageClass")
6. Apply the default configuration for local data storemode.
   By default, Simulink sets the storage class for data stores toAuto. When the storage class is Auto, the code generator:
   • Determines whether to eliminate the data from the generated code for optimization purposes.
   • If retaining the data, determines how to efficiently represent the data in the generated code, taking into account default configuration settings.
     To control the configuration for an individual data store, call functionsetDataStore. Issue a call tosetDataStore that specifies:
   • Object returned bycoder.mapping.api.get
   • Data store name mode
   • Default storage class previously set for the data store by using property StorageClass and property valueModel default.
   • Property Identifier and property valueds_mode
     setDataStore(cm,"mode","StorageClass","Model default","Identifier","ds_mode");
7. Verify your configuration changes by calling functiongetDataStore. Specify the object returned bycoder.mapping.api.get, the name of the data store, and property StorageClass orIdentifier.
   getDataStore(cm,"mode","StorageClass")
   getDataStore(cm,"mode","Identifier")
8. Save the model.
9. Generate and view the code. For example, in ConfigurationInterface.c, find the data definition for the data store.
   static boolean_T ds_mode;
   Find where the data store is used in the step entry-point function.
   .
   .
   .
   ds_mode = ((input1 > ConfigurationInterface_UPPER) || (input1 <
   ConfigurationInterface_LOWER));

.
.
.
if (ds_mode) {
output = (real_T)mp_K1 * dout_Table1;
} else {
output = dstate_X;
}
.
.
.

Choose Storage Class and Storage Class Properties for Data Stores

Depending on your code generation requirements, choose from these storage classes to configure code generation for data stores. The list of storage classes is defined in the coder dictionary.

The list of available storage classes might include other project-specific storage classes defined in an Embedded Coder Dictionary. If you have special requirements that are not met by the listed storage classes and you have Embedded Coder software, you can define a storage class. See Define Service Interfaces, Storage Classes, Memory Sections, and Function Templates for Software Architecture.

For an individual data store, use the Identifier storage class property to configure a name for the variable representing the data store in the generated code. With Embedded Coder, depending on the storage class that you choose, you can also configure these properties.

See Also

Code Mappings Editor – C | coder.mapping.api.CodeMapping

Topics

• C Data Code Interface Configuration for Model Interface Elements
• Choose Storage Class for Controlling Data Representation in Generated Code
• Use Built-In and Predefined Storage Classes to Represent Data in Generated Code
• Configure Default C Code Generation for Categories of Data Elements and Functions
• Configure Model Data Elements for ASAP2 File Generation