1.1 The hand written header file

Size: px

Start display at page:

Download "1.1 The hand written header file"

Jocelin Robertson
5 years ago
Views:

1 Page 1 of 8 Incorporating hand code data with generated code from 1 Overview models This paper illustrates how to integrate hand-code with the code generated from models. In particular, it will illustrate how to take three pieces of data that are defined in hand-written files and generate code from a model that will compile with the hand-written files without any handmodification of code. For this example, the hand-written files consist of a header file and a source file that provide three pieces of data: two signals and a parameter. 1.1 The hand written header file #ifndef _HAND_WRITEN_FILE_H_ # define _HAND_WRITEN_FILE_ extern double hand_code_signal_variable_a; extern double * hand_code_signal_variable_b_ptr; extern double hand_code_parameter_c; #else /* This file has already been included. */ #endif /* _HAND_WRITEN_FILE_H_ */ The example header file, hand_written_file.h, simply provides extern declarations of the data. In this case, hand_code_signal_variable_a will be accessed directly, but hand_code_signal_variable_b_ptr is a pointer and must be dereferenced when it is used (e.g. (*hand_code_signal_variable_b_ptr)). Text 1: hand_written_file.h 1.2 The hand written source file The example source file, hand_written_file.c, provides the actual definitions of the data. This file also clarifies why hand_code_signal_variable_b_ptr has to be a pointer instead of a normal variable; In this case, it points to a hardware address instead of a normal variable. Also, this file also defines the value of hand_code_parameter_c, and the initial value of hand_code_signal_variable_a which are relevant because it is necessary to ensure that simulation uses the same values that will be compiled into the generated code. #ifndef _HAND_WRITEN_FILE_C_ # define _HAND_WRITEN_FILE_C_ # include "hand_written_file.h" # define HARDWARE_ADDRESS ((double *)12345) double hand_code_signal_variable_a; double * hand_code_signal_variable_b_ptr = HARDWARE_ADDRESS; double hand_code_parameter_c = 42; #else /* This file has already been included. */ #endif /* _HAND_WRITEN_FILE_C_ */ Text 2: hand_written_file.c

2 Page 2 of The model The model for this example, will be named model_using_external_variables.mdl, and will be a simple use of a Gain block applied to an incoming signal, as illustrated below: Illustration 1: Initial model_using_external_variables.mdl This model will incorporate the three pieces of data from the hand-written files in the following manner: hand_code_signal_variable_a will be the incoming signal hand_code_signal_variable_b_ptr will be the outgoing signal hand_code_parameter_c will be the gain value applied to the incoming signal to produce the outgoing signal. It is worth noting that, from a C programming perspective, these pieces of data are all declared and defined in roughly the same fashion, and the distinctions between input signals, output signals, and parameters is defined by how the data will be used in the model. 2 Steps In order to use this data in the generated code, it will be necessary to ensure that the generated code to do two things: Use the data, as named in the hand-written files, in the generated code: This will be done by creating data objects and applying them to elements of the model, as well as modifying the model's Configuration Parameters. Include the hand-written files into the model's build process: This will be done by modifying the model's Configuration Parameters. 2.1 Using the data Data objects provide a mechanism for controlling the code-generation details of signals and parameters. In this case, it will be necessary to create data objects for hand_code_signal_variable_a, hand_code_signal_variable_b_ptr and hand_code_parameter_c. These data objects can be created using the following m-code:

3 Page 3 of 8 function create_hand_written_file_data_objects() hand_code_signal_variable_a = mpt.signal; hand_code_signal_variable_a.rtwinfo.storageclass = 'Custom'; hand_code_signal_variable_a.rtwinfo.customstorageclass = 'ImportFromFile'; hand_code_signal_variable_a.rtwinfo.customattributes.dataaccess = 'Direct'; hand_code_signal_variable_a.rtwinfo.customattributes.headerfile = 'hand_written_file.h'; hand_code_signal_variable_a.datatype = 'double'; hand_code_signal_variable_a.initialvalue = '42.0'; hand_code_signal_variable_b_ptr = mpt.signal; hand_code_signal_variable_b_ptr.rtwinfo.storageclass = 'Custom'; hand_code_signal_variable_b_ptr.rtwinfo.customstorageclass = 'ImportFromFile'; hand_code_signal_variable_b_ptr.rtwinfo.customattributes.dataaccess = 'Pointer'; hand_code_signal_variable_b_ptr.rtwinfo.customattributes.headerfile = 'hand_written_file.h'; hand_code_signal_variable_b_ptr.datatype = 'double'; hand_code_parameter_c = mpt.parameter; hand_code_parameter_c.value = double(2112.0); hand_code_parameter_c.rtwinfo.storageclass = 'Custom'; hand_code_parameter_c.rtwinfo.customstorageclass = 'ImportFromFile'; hand_code_parameter_c.rtwinfo.customattributes.dataaccess = 'Direct'; hand_code_parameter_c.rtwinfo.customattributes.headerfile = 'hand_written_file.h'; assignin('base', 'hand_code_signal_variable_a', hand_code_signal_variable_a); assignin('base', 'hand_code_signal_variable_b_ptr', hand_code_signal_variable_b_ptr); assignin('base', 'hand_code_parameter_c', hand_code_parameter_c); end Text 3: create_hand_written_file_data_objects.m After running this code, the data objects now exist in the base workspace, but the model does not yet use them. The next step is to associate these data objects with elements of the model Associating model signals with signal data objects To associate a model signal with a signal data object in the base workspace, 1. Right-click on the signal line to be associated with the data object, and select Signal Properties. 2. Enter the name of the data object into the Signal name text field. 3. Check the Signal name must resolve to Simulink signal object box. 4. Click OK. Illustration 2: Signal Properties window

Use the parameter name in a block dialog 2.

4 Page 4 of Associating block dialog parameters with parameter data objects To associate a parameter data object in the base workspace with a block: 1. Use the parameter name in a block dialog 2. Inline parameters, by opening Simulation- >Configuration Parameters, then selecting Optimization from the tree on the left, and then checking the box for Inline parameters. Illustration 3: Gain block parameters dialog Illustration 4: Configuration Parameters, Optimization pane After naming the signals and adding the parameter to the Gain block, the final model should look like the following:

5 Page 5 of 8 Illustration 5: Completed model_using_external_variables.mdl With the data objects properly associated with the model, the generated code will now contain some of the key elements that are required to make use of the generated code, including: Preprocessor inclusion directives /* Includes for objects with custom storage classes. */ #include "hand_written_file.h" Text 4: From model_using_external_variables_private.h Use of the correct variable names #include "model_using_external_variables.h" #include "model_using_external_variables_private.h" /* Model step function */ void model_using_external_variables_step(void) { /* Gain: '<Root>/Gain' incorporates: * Inport: '<Root>/In1' */ (*hand_code_signal_variable_b_ptr) = hand_code_parameter_c * hand_code_signal_variable_a; } Text 5: From model_using_external_variables.c However, even though the resulting code will be correct, Real-Time Workshop is not yet able to compile or link it because it is not yet able to access the hand-written header and source files during the build process.

6 Page 6 of Including the hand written files into the build process Including the path to the hand written header file in the generated makefile The code-generation associated with the data objects causes the correct # include statements to be produced, but the actual header file is not in any of the directories that the compiler will access. It is therefore necessary to add the directory containing the header file to the build command. To do this: 1. Open Simulation->Configuration Parameters. 2. Select Real-Time Workshop->Custom Code from the tree on the left. 3. Select Include directories the Include list of additional (lower) section. 4. Enter the path to the header files, not including the actual name of the header file, which is actually specified by the # include statement. The path may either be absolute, or relative to the model file. Illustration 6: Configuration parameters, include directories pane This results in the following information being added to the automatically-generated makefile:

$Page 7 of 8 # Additional includes ADD_INCLUDES = \ -I/path/to/model/file/model/model_using_external_variables_ert_rtw \ -I/path/to/model/file/model \ -I/path/to/model/file/model/.$

7 Page 7 of 8 # Additional includes ADD_INCLUDES = \ -I/path/to/model/file/model/model_using_external_variables_ert_rtw \ -I/path/to/model/file/model \ -I/path/to/model/file/model/../hand_code \ -I$(MATLAB_ROOT)/rtw/c/libsrc \ Text 6: From model_using_external_variables.mk Including the hand written source file in the generated makefile's build list Having completed the above steps, the model will successfully compile, however the linking process will fail because there is no object file that actually defines hand_code_signal_variable_a, hand_code_signal_variable_b_ptr or hand_code_parameter_c, so the references in the generated code (and header file) remain unresolved. The solution is to add hand_written_file.c to the makefile for compilation. To do this: 1. Open Simulation->Configuration Parameters. 2. Select Real-Time Workshop->Custom Code from the tree on the left 3. In the Include list of additional (lower pane) section, select Source files. 4. In the Source files (lower pane) section enter the path and file name (either an absolute path, or relative to this model file). Illustration 7: Configuration Parameters, Source files pane

8 Page 8 of 8 This will produce the following addition to the generated makefile: MODEL MODULES = model_using_external_variables = hand_written_file.c %.o : /path/to/model/file/model/../hand_code/%.c $(CC) -c $(CFLAGS) $(GCC_WALL_FLAG_MAX) "$<" %.o : /path/to/model/file/model/../hand_code/%.cpp $(CPP) -c $(CPPFLAGS) $(GCC_WALL_FLAG_MAX) "$<" Text 7: From model_using_external_variables.mk

Separate Compilation of Multi-File Programs

Separate Compilation of Multi-File Programs 1 About Compiling What most people mean by the phrase "compiling a program" is actually two separate steps in the creation of that program. The rst step is proper compilation. Compilation is the translation