How to call the embedded code using user defined function blocks in matlab

I have some stm32 codes and i need to integrate that in matlab environment using s function/ c function / c caller blocks. And that particular code have one main header and source and also other librray files that is associated with the stm board. Can someone help me with intergrating that particular code with simulink environment and test that functions.

And if I have to use s function block for above problem how to do that?

Answer 1

[Umar]

Hi @AKHILA ,

You mentioned, “I have some stm32 codes and i need to integrate that in matlab environment using s function/ c function / c caller blocks. And that particular code have one main header and source and also other librray files that is associated with the stm board. Can someone help me with intergrating that particular code with simulink environment and test that functions. And if I have to use s function block for above problem how to do that?”

Please see my response to your comments below.

After reviewing the mathworks documentations regarding c caller block and s function block provided in the links below

https://www.mathworks.com/help/simulink/sfg/integrating-existing-c-functions-into-simulink-models-with-the-legacy-code-tool.html

https://www.mathworks.com/help/simulink/slref/sfunction.html

This is how you can integrate your STM32 C code into the MATLAB Simulink environment using S-Function blocks, you can leverage the Legacy Code Tool. This tool is designed for incorporating existing C or C++ functions into Simulink models, allowing you to create C MEX S-functions from your code. Below are detailed steps to guide you through this integration:

Step 1: Prepare Your C Code

Make sure that your C code (including header and source files) is accessible in a directory that MATLAB can access. If your STM32 project has multiple source files, ensure they are all included in this directory.

Step 2: Initialize Legacy Code Tool Data Structure

Start by initializing the Legacy Code Tool data structure. Open MATLAB and run the following command:

def = legacy_code('initialize');

This creates a structure def with fields that you will populate with relevant information about your C function.

Step 3: Specify Your C Function Details

Fill in the fields of def with details about your existing C function. For instance, if your main function is named myFunction, your setup might look like this:

def.SFunctionName = 'my_sfun';  % Name for the generated S-function
def.SourceFiles = {'myFunction.c', 'otherSource.c'};  % List all source files
def.HeaderFiles = {'myFunction.h'};  % List header files
def.OutputFcnSpec = 'double y1 = myFunction(double u1)';  % Specify output 
function

Make sure to adjust the OutputFcnSpec according to your function's signature.

Step 4: Generate the S-Function

Use the following command to generate the S-function from your specified details:

legacy_code('sfcn_cmex_generate', def);

This command creates a .c file corresponding to your S-function in the current directory.

Step 5: Compile the S-Function

Next, compile the generated S-function with:

legacy_code('compile', def);

This will produce a dynamically loadable executable (.mex file) that can be used within Simulink.

Step 6: Create a Masked S-Function Block in Simulink

To create a masked block for easier usage in Simulink, run:

legacy_code('slblock_generate', def);

This generates a masked S-Function block that reflects the properties defined in your def structure.

Step 7: Integrate into Simulink Model

Open or create a Simulink model and drag the generated masked S-Function block into it. Connect appropriate input and output signals as required by your application.

After integrating the block into your model, it's essential to simulate and validate its behavior. Use scopes or display blocks to monitor outputs and verify that they match expected results. If you encounter issues during compilation or simulation, check for:

1. Correct paths to source/header files.

1. Item twoProper specification of data types in OutputFcnSpec.

1. Compatibility of MATLAB's supported data types with those in your C code.

1. Refer to Matworks documentation.

Now, if you plan to deploy this model on hardware (like STM32), ensure that timing constraints are met, especially when dealing with real-time systems.

Hope this answers all your questions.

[AKHILA]

@UmarThank you for your answer. What if my c code contain more than one function?

And also if function is like void led(void) how to define that in outputFCnSpec?

It will be really helpful if this doubt is cleared.

[Umar]

Hi @AKHILA ,

You mentioned, “What if my c code contain more than one function? And also if function is like void led(void) how to define that in outputFCnSpec?It will be really helpful if this doubt is cleared.”

Please see my response to your comments below.

First, let me address your query regarding, “ What if my c code contain more than one function? ”

In C, you probably know that functions can be defined with different return types and parameters. For example:

void led(void) {
  // Function implementation
}

So, as you can see in above example code snippet, this function does not return any value and takes no parameters. If you have multiple functions, each should be defined clearly with its purpose.

Now addressing your second query regarding, “ also if function is like void led(void) how to define that in outputFCnSpec ”

If you read the documentations provided above, you will find out that the OutputFcnSpec defines how the function will be called during simulation. For a function like void led(void) as mentioned by you, it does not return a value or take any input parameters, you can define it as follows:

def.OutputFcnSpec = 'void led()';

However, if led() affects some state or outputs data that needs to be captured, you might want to consider redesigning it to return a value or accept parameters that can be passed during the simulation. Now, to integrate multiple legacy C functions using the Legacy Code Tool, follow these steps:

Initialize the Definition Structure: Each function must have its own definition structure.

Set Properties: For each function, specify its name, header files, source files, and output function specifications. Here is an example for two functions: led() and another hypothetical function filter():

defs = [];

// Define for led()
def = legacy_code('initialize');
def.SFunctionName = 'sldemo_sfun_led';
def.OutputFcnSpec = 'void led()'; // Specifying no inputs/outputs
def.HeaderFiles   = {'my_led.h'};
def.SourceFiles   = {'led.c'};
defs = [defs; def];

// Define for filter()
def = legacy_code('initialize');
def.SFunctionName = 'sldemo_sfun_filter';
def.OutputFcnSpec = 'single y1 = filter(single u1, single p1)';
def.HeaderFiles   = {'myfilter.h'};
def.SourceFiles   = {'filter.c'};
defs = [defs; def];

After defining your functions, generate the corresponding S-functions by calling:

legacy_code('generate_for_sim', defs);

This will compile your C code into MEX files that MATLAB can call during simulations.

Now, if your led() function needs to take parameters (e.g., intensity), consider modifying its signature accordingly. Make sure that any state changes made by led() are accessible within your simulation context. You may need global variables or external data structures if you want to capture state changes that occur due to calls from led().

[AKHILA]

@UmarThanks for your help.

[Umar]

Hi @ AKHILA,

It’s my pleasure.