MATLAB Examples

Processor-in-the-Loop Verification of MATLAB Functions

This example shows you how to use Embedded Coder Support Package for STMicroelectronics Discovery Boards for Processor-in-the-Loop (PIL) verification of MATLAB® functions.



In this example you will learn how to generate a PIL MEX function from a simple MATLAB function. When you run the the PIL MEX function, the C-code generated from your MATLAB function runs on the STMicroelectronics STM32F4-Discovery board, an ARM Cortex-M4 based microcontroller. The results are transferred to MATLAB for numerical verification. During this process, you can profile the code execution. The PIL verification process is a crucial part of the design cycle to ensure that the behavior of the deployment code matches the design.


Required Hardware

To run this example you will need the following hardware:

  • STMicroelectronics STM32F4-Discovery board or STM32F746G-Discovery board
  • USB type A to Mini-B cable

Serial communication for STM32F4-Discovery board:

  • USB TTL-232 cable - TTL-232R 3.3V Notes:
  • This example was tested with the FTDI Friend USB TTL-232R 3.3V adapter.

Task 1 - Create a New Folder and Copy Relevant Files

The following code will create a folder in your current working folder. The new folder will only contain the files that are relevant for this example. If you do not want to affect the current folder (or if you cannot generate files in this folder), you should change your working folder.


In this example, we use the simple_addition.m function that simply adds two inputs and returns the result. To see the contents of this function:

type simple_addition

The %#codegen directive in this function indicates that the MATLAB code is intended for code generation.

Task 2 - Generate PIL MEX Function from command line

The following steps provide commands to generate code and a library for a MATLAB function to verify on STM32F4-Discovery board.

Step 1: Create a coder.EmbeddedCodeConfig object to generate code and create a library for MATLAB function simple_addition.

config = coder.config('lib','ecoder',true);

Step 2: Configure the object for PIL.

config.VerificationMode = 'PIL';

Step 3: Specify the hardware on which the generated code to be verified.

config.Hardware = coder.hardware('STM32F4-Discovery');

Step 4: The STM32F4-Discovery board supports two different communication interfaces for PIL, namely ST-LINK and Serial (USART2). The ST-LINK communication interface does not require any additional cables or hardware besides a USB type A to Mini-B cable used to connect the STM32F4-Discovery board to the host computer. The serial communication interface requires a USB TTL-232 cable. Running a PIL simulation using the serial communication interface is much faster than the running a PIL simulation using 'ST-LINK'. We recommend using the serial interface 'Serial (USART2)' for PIL whenever possible.

To choose 'ST-LINK' as PIL commnunication interface, below is the step:

config.Hardware.PILInterface = 'ST-LINK';

To choose 'Serial (USART2)' as PIL commnunication interface, below are the steps.

config.Hardware.PILInterface = 'Serial (USART2)';
config.Hardware.PILCOMPort = 'COM28';

To set PILCOMPort, follow the steps 2 to 4 specified in Code Verification and Validation with PIL to find the COM port for serial communication.

Step 5: Limit the stack size to reasonable size, for example 512 bytes, as default size is much larger than the memory available on the hardware.

config.StackUsageMax = 512;

Step 6: You can enable verbose build to view the build log on command line.

config.Verbose = 1;

Step 7: Generate library code for the simple_addition MATLAB function and the PIL interface.

inp = single(zeros(1,30));
codegen('-config', config, '-args', {inp,inp}, 'simple_addition');

In above commands, inp declares the data type and size for input arguments to MATLAB function 'simple_addition'. The codegen command generates code into following folders

  • codegen\lib\simple_addition - Standalone code for simple_addition.
  • codegen\lib\simple_addition\pil - PIL interface code for simple_addition.

Also, this step creates simple_addition_pil PIL MEX function in the current folder. This allows you to test the MATLAB code and the PIL MEX function and compare the results between both.

Task 3 - Run the PIL MEX Function

Run the PIL MEX function to compare its behavior to that of the original MATLAB function and to check for run-time errors.

u1 = single(rand(1,30));
u2 = single(rand(1,30));
y = simple_addition_pil(u1,u2);

Terminate PIL execution with the following command.

clear simple_addition_pil;

Task 4 - Verify Generated Code

To verify the numerical accuracy of the generated code, compare MATLAB results with those of the PIL MEX function:

norm(y - simple_addition(u1,u2))

Task 5 - Profile Generated Code

To enable code execution profiling, set CodeExecutionProfiling of the coder.EmbeddedCodeConfig coder configuration object to true before generating code for the MATLAB function in Step 7 of Task 2.

config.CodeExecutionProfiling = true;

When profiling is enabled, the generated code is instrumented with timing information. The profiling results are transferred to MATLAB when the PIL MEX function is cleared from memory.

To accumulate profiling results, run simple_addition function 100 times in a loop:

for k=1:100, y = simple_addition_pil(u1,u2); end

The profiling results are available after clearing the PIL MEX function:

clear simple_addition_pil

Bring up the profiling report:

ProfileResultsWithoutCRL = getCoderExecutionProfile('simple_addition');

Task 6 - Use 'ARM Cortex-M' Code Replacement Library (CRL)

To take advantage of optimized CRL for ARM Cortex-M processors, assign CodeReplacementLibrary library 'ARM Cortex-M (CMSIS)' and re-build the PIL MEX function following Step 7 of Task 2:

config.CodeReplacementLibrary = 'ARM Cortex-M (CMSIS)';

Run the simple_addition function 100 times in a loop to accumulate profiling results:

for k=1:100, y = simple_addition_pil(u1,u2); end

The profiling results are available after clearing the PIL MEX function:

clear simple_addition_pil

Bring up the profiling report:

ProfileResultsWithCRL = getCoderExecutionProfile('simple_addition');

Compare the profiling results to those obtained in Task 5.


This example introduced the workflow for code verification of MATLAB functions using PIL.