Generate Code for Wireless Sensor in Tire Pressure Monitoring Messaging System

Review Distributed Messaging System

The messaging system highlighted in this example represents an automotive tire pressure monitoring system that uses identical pressure sensors at each wheel.

Sensors communicate wirelessly with the controller in the vehicle and publish periodic messages consisting of acquired pressure data and a unique device ID. The sensor device ID is stored in nonvolatile memory on the sensor and serves as the message topic ID. Device IDs are used to uniquely identify which sensors are associated with the tires installed in the vehicle, as the vehicle might be among many other cars in traffic and erroneous messages must be identified and rejected.

The controller receives the messages and inspects the sender device ID against a list of the relevant sensor IDs to determine which communications to examine and which ones to reject. The controller then evaluates payload pressure data from the relevant sensors for fault conditions. If the controller detects a fault condition, it indicates an error and aggregates the fault condition in a log that is stored in controller NVM.

The system-level model tirePressureMonitoringSystem contains multiple identical tire pressure sensors modeled by multi-instanced Model blocks that are routed to the controller. Messages are sent by using the Message Send block, which reads the value of an input signal and converts it to a message that carries the signal value. Since all four sensors in the vehicle execute the same algorithm, you deploy the same code to each sensor. The only difference among the sensors is the unique sensor ID, which is burned into the NVM of each sensor before code execution.

The models and deployment steps in this example support a manufacturing process similar to the following:

The following sections in this example focus on steps 2 and 3 of the overall manufacturing process and explain how to generate deployable code for the sensor component in this distributed messaging system. For more information about modeling the sensor core algorithm or system-level simulation, see Wireless Tire Pressure Monitoring System with Fault Logging.

Access Models and Other Project Files

The models and support files for this example are contained in a Simulink project.

When you open the project, the project creates working folder slexTirePressureMonitoringSystem under your MATLAB current folder and runs the project initialization script.

After the project opens, your working folder contains the top-level items shown in this image.

Open Wrapper Model for Sensor

The wrapper model sensorCodeGenerationWrapper is a top-level model that isolates the sensor core model for code generation. In the current folder, navigate to models > sensor > wrappers, and open sensorCodeGenerationWrapper.slx.

The base algorithm for the sensor model converts pressure readings into messages that can be used with a messaging protocol and is implemented in sensorCoreAlgorithmModelReference, a reference to the sensorCoreAlgorithm model in the system-level model.

Locate Simulink Blocks that Contain Hooks for Inserting External Code

How you read NVM, acquire pressure data, and transmit messages depends on what operating system, tire pressure monitoring system (TPMS) sensor, and messaging protocol you are using. For this example, those system-dependent tasks require custom externally-written code.

MATLAB Function blocks in the wrapper model contain hooks for inserting the external code into the generated C code. This example uses the abstract class coder.ExternalDependency for code insertion.

In the sensor wrapper, the following blocks call public methods defined in the class SensorTargetSpecificCodeExternalDependency, a subclass of coder.ExternalDependency:

For managing the sensor ID in NVM at startup, readNVMInitialization contains these blocks:

To explore hooks in readNVMInitialization:

function extractedDeviceID = readNVMMATLABFunction(SENSOR_PARAMETERS_NVM_ADDRESS_AS_UINT32)
coder.extrinsic( 'warning' );
defaultDeviceID = deviceIDBusTypeDefaultConstructor( );

if( coder.target( 'Rtw' ) )
    extractedDeviceID = ...
        SensorTargetSpecificCodeExternalDependency.sensorReadNVMMatlabWrapper( SENSOR_PARAMETERS_NVM_ADDRESS_AS_UINT32, defaultDeviceID );
else
    warning( 'This block is intended only for code generation.' );
    extractedDeviceID = defaultDeviceID;
end
return;

end

The function readNVMMATLABFunction references the coder.ExternalDependency subclass SensorTargetSpecificCodeExternalDependency.

To view the class definition for SensorTargetSpecificCodeExternalDependency and code for creating the function readNVMMATLABFunction:

Note that the coder.ceval statement invokes the external source code in sensor_read_nvm to the code generator.

You can repeat these steps to explore the MATLAB Function blocks for inserting custom code that acquires the pressure readings and transmits messages:

For more information about using coder.ExternalDependency for code integration, see Develop Interface for External C/C++ Code.

Integrate Custom Target-Specific Driver and Middleware Code

You customize this example by incorporating driver and middleware code specific to your system. You include your custom code in the generated code by updating the preexisting stub functions in the source and header files:

To include target-specific code:

/*
* The functions below are stubbed to allow compilation. However, the premise of the example is that these functions
* are target-specific and would not be compiled for desktop simulation.
*/

#include "sensor_hand_code_header.h"

void sensor_read_nvm( void * nvm_source_address, void * ram_destination_addresss, size_t single_element_size, size_t element_quantity_to_copy ) {
    return;
}

extern double sensor_read_pressure( void ){
   double result = 0.0;
   return( result );
}

void sensor_transmit_data( void * message_source_address, size_t single_element_size, size_t element_quantity_to_send ){
    return;
}

The functions insert into the generated code by using the coder.ceval command in the MATLAB Function block definitions.

Build and Generate C Code from Sensor Wrapper

Open the Embedded Coder app and build the sensor wrapper. Simulink builds the models and support files and generates code.

Generated code for the sensor wrapper and referenced core algorithm is located under the generated_code folder in your current folder:

Inspect Generated Makefile and Build Information

Embedded Coder generates the customized makefile sensorCodeGenerationWrapper.mk by modifying a template makefile with specifics of the Simulink models and further modifications introduced by using the coder.ExternalDependency subclass.

Specifically, SensorTargetSpecificCodeExternalDependency.m invokes coder.ExternalDependency.updateBuildInfo to modify the build information object buildInfo and provide additional information required to link to external code. This information includes the external files defined in the class.

properties( ...
       ...
       )
    HEADER_FILE_SHORT_NAME = 'sensor_hand_code_header.h';
    SOURCE_FILE_SHORT_NAME = 'sensor_hand_code_source.c';
end

methods( ...
       ...
       )
    ...
    function [ ] = updateBuildInfo(buildInfo,buildContext)

         externalCodeRootDirectoryAbsolutePath = ...
             SensorTargetSpecificCodeExternalDependency.getHandCodeRootDirectoryAbsolutePath( );

         headerFileDirectoryAbsolutePath = ...
             fullfile(externalCodeRootDirectoryAbsolutePath,'include');

         buildInfo.addIncludePaths(headerFileDirectoryAbsolutePath);

         sourceFileDirectoryAbsolutePath = ...
             fullfile(externalCodeRootDirectoryAbsolutePath,'source');

         buildInfo.addSourceFiles(SensorTargetSpecificCodeExternalDependency.SOURCE_FILE_SHORT_NAME);

         buildInfo.addSourcePaths(sourceFileDirectoryAbsolutePath);

         return;

     end

When you build the wrapper model, the code generator adds external code to the makefile and build information.

Open sensorCodeGenerationWrapper.mk located in generated_code > sensorCodeGenerationWrapper_ert_rtw to review the external source files and objects, which include sensor_hand_code_source.c and sensor_hand_code_source.obj, respectively. An example of this in the makefile is:

...
## SOURCE FILES
SRCS = sensor_hand_code_source.c $(START_DIR)\sensorCodeGenerationWrapper_ert_rtw\sensorCodeGenerationWrapper.c $(START_DIR)\sensorCodeGenerationWrapper_ert_rtw\sensorCodeGenerationWrapper_data.c
MAIN_SRC = $(START_DIR)\sensorCodeGenerationWrapper_ert_rtw\ert_main.c
ALL_SRCS = $(SRCS) $(MAIN_SRC)

## OBJECTS
OBJS = sensor_hand_code_source.obj sensorCodeGenerationWrapper.obj sensorCodeGenerationWrapper_data.obj
MAIN_OBJ = ert_main.obj
ALL_OBJS = $(OBJS) $(MAIN_OBJ)
...

The absolute path for the external source file is defined in updateBuildInfo by using addSourcePaths. You can review the makefile to confirm the absolute path for the target object for the external source code sensor_hand_code_source.c.

## INTERMEDIATE TARGETS
# SOURCE-TO-OBJECT

.c.obj :
   $(CC) $(CFLAGS) -Fo"$@" "$<"
...
{C:\<yourPath>\examples\slexTirePressureMonitoringSystem\models\sensor\target_specific_code\source}.c.obj :
   $(CC) $(CFLAGS) -Fo"$@" "$<"

The absolute path for the external include file is defined in updateBuildInfo by using addIncludePaths. The path for the external header file sensor_hand_code_source.h is specified in the response file sensorCodeGenerationWrapper_comp.rsp, which is a text file that contains data to include as command-line arguments to the Windows compiler.

Open the file sensorCodeGenerationWrapper_comp.rsp, which is also located in generated_code > sensorCodeGenerationWrapper_ert_rtw, to review the include folders and confirm the folder path for the external target-specific header file. An example of the include arguments is:

...
-IC:/<yourPath>/examples/slexTirePressureMonitoringSystem66/models/sensor/target_specific_code/include
-IC:/<yourPath>/examples/slexTirePressureMonitoringSystem66/generated_code/sensorCodeGenerationWrapper_ert_rtw
...

The generated makefile and supplemental compiler command-line arguments instruct the make system utility to compile and link code generated from the model and the externally provided source and header files.

Inspect Generated C Code for Sensor

In the Embedded Coder app, you can inspect the entry-point functions containing your custom code and the sensor core algorithm in the generated code.

Under the C Code tab, open the Code pane to view the generated code.

Inspect the initialization function sensorCodeGenerationWrapper_initialize defined in sensorCodeGenerationWrapper.c. The initialization function:

/* Model initialize function */
void sensorCodeGenerationWrapper_initialize(void)
{

   /* states (dwork) */
   rtDW.sensorCoreAlgorithmModelReference_InstanceData.rtdw.sensorMeasurmentMessageOutputPort_SendData.SendData
     = Receive_SendData;
   rtDW.sensorCoreAlgorithmModelReference_InstanceData.rtdw.sensorMeasurmentMessageOutputPort_SendData.host
     = (NULL);

   /* Assign pointer for instance parameters, Block: '<Root>/sensorCoreAlgorithmModelReference' */
   rtDW.sensorCoreAlgorithmModelReference_InstanceData.rtm.sensorCoreAlgorithm_InstP_ref
     = &rtInstP.sensorCodeGenerationWrapperrtsensorCoreAlgorithmModelReference;

   {
     DeviceIDBusType s;
     int32_T i;

     /* Start for slMsgMgr: '<Root>/slMsgMgr' */
     sensorCodeGenerationWrapper_initMemPool
       (&rtDW.slMsgMgr_MemPool_MeasurementMsgBusType,
        &rtDW.slMsgMgr_memArray_MeasurementMsgBusType[0],
        &rtDW.slMsgMgr_freeList_MeasurementMsgBusType[0], 2);

     /* Start for Receive: '<Root>/Receive' */
     rtDW.Receive = rtP.Receive_InitialValue;

     /* Outputs for Atomic SubSystem: '<Root>/readNVMInitializeFunction' */
     /* MATLAB Function: '<S1>/readNVMMATLABFunction' */
     for (i = 0; i < 10; i++) {
       s.device_id[i] = 0U;
     }

     size_t elementSize;
     elementSize = sizeof(s);

     /* ParameterWriter: '<S1>/localDeviceIDParameterWriter' incorporates:
      *  MATLAB Function: '<S1>/readNVMMATLABFunction'
      */
     sensor_read_nvm((void *)rtP.SENSOR_PARAMETERS_NVM_ADDRESS_AS_UINT32,
                     &rtInstP.sensorCodeGenerationWrapperrtsensorCoreAlgorithmModelReference.LOCAL_DEVICE_ID,
                     elementSize, (size_t)1.0);

     /* End of Outputs for SubSystem: '<Root>/readNVMInitializeFunction' */
   }
 }

Inspect the execution step function sensorCodeGenerationWrapper_step defined in sensorCodeGenerationWrapper.c. The step function:

Inspect the sensor core algorithm sensorCoreAlgorithm defined in sensorCoreAlgorithm.c. The sensor core algorithm constructs a message from the unique sensor ID, LOCAL_DEVICE_ID , and the data acquisition payload, real_T rtb_pressure, as MeasurementMsgBusType structure elements for transmission.

Note that sensorCoreAlgorithm.c is generated from the shared reference model. You can double-click the sensorCoreAlgorithmModelReference block in the sensor wrapper model to open sensorCoreAlgorithm.c in the Code pane.