Save/Load Simulink Code-Generated State

Is it possible to save/serialize the internal state structs of a Simulink code-generated model, and re-load those on a later initialization?

To prevent X/Y problem, I am using a GRT code-generated Simulink model to simulate a specific plant. My controls are neccessarily but unfortunately outside of Matlab/Simulink. I would like to modify parameters in a control scheme and assess their performance over a specific region of the simulation. Essentially like in a video game, you may fail some challenge and you are restarted at some checkpoint.

I have tried using a reusable function, and then use the tool 'cser' to serialize the main model struct, however it quickly gets confused with the vast number of types pointing to other types. Additionally, some of the structs contain pointers, so I can't simply write the memory of the struct to a file.

Answer 1

[Namnendra]

Hi Ethan,

Yes, it is possible to save and reload the internal state of a Simulink code-generated model, but it requires a careful approach due to the complexity and the use of pointers within the generated code. Here’s a structured way to achieve this:

Step-by-Step Guide

1. Identify the State Variables: Determine which state variables and structures you need to save. Typically, these include continuous states, discrete states, and possibly other internal variables.

2. Modify Code Generation Settings: Ensure that the code generation settings in Simulink are configured to generate code that allows access to these state variables. You may need to enable logging or external mode features.

3. Create Save and Load Functions: Write custom functions to serialize (save) and deserialize (load) the state variables. This involves converting the state information into a format that can be stored in a file and then read back into the program.

4. Handle Pointers and Complex Structures: Since the generated code may use pointers and complex structures, you will need to carefully handle these when saving and loading the state. This might involve creating a custom serialization format or using existing libraries that can handle complex data structures.

Example Implementation

Here’s an example of how you might implement the save and load functionality in C:

Save Function:

#include <stdio.h>
#include "your_model.h"  // Include your generated model header

void saveModelState(RT_MODEL_your_model_T *model, const char *filename) {
FILE *file = fopen(filename, "wb");
if (file == NULL) {
    perror("Error opening file for writing");
    return;
    }
    
    // Save continuous states
    fwrite(model->contStates, sizeof(real_T), model->Sizes.numContStates, file);
    
    // Save discrete states
    fwrite(model->dwork, sizeof(D_Work_your_model_T), 1, file);
    
    fclose(file);
    }

Load Function:

    #include <stdio.h>
    #include "your_model.h"  // Include your generated model header
    
    void loadModelState(RT_MODEL_your_model_T *model, const char *filename) {
    FILE *file = fopen(filename, "rb");
    if (file == NULL) {
        perror("Error opening file for reading");
        return;
        }
        
        // Load continuous states
        fread(model->contStates, sizeof(real_T), model->Sizes.numContStates, file);
        
        // Load discrete states
        fread(model->dwork, sizeof(D_Work_your_model_T), 1, file);
        
        fclose(file);
        }

Integrate with Your Control Scheme

1. Initialize the Model: Initialize the Simulink model as usual.

2. Modify Parameters: Adjust the parameters of your control scheme.

3. Run Simulation: Run the simulation for a specific region.

4. Save State: If you reach a "checkpoint," call the `saveModelState` function to save the current state.

5. Load State: If you need to restart from the checkpoint, call the `loadModelState` function to restore the state.

Example Usage

        int main() {
        // Initialize model
        RT_MODEL_your_model_T *model = your_model();
        
        // Modify parameters
        // ... (your control scheme modifications)
            
        // Run simulation
        // ... (your simulation code)
            
        // Save state at a checkpoint
        saveModelState(model, "checkpoint.dat");
        
        // Modify parameters again
        // ... (your control scheme modifications)
            
        // Load state from the checkpoint
        loadModelState(model, "checkpoint.dat");
        
        // Continue simulation
        // ... (your simulation code)
            
        return 0;
        }

Considerations

1. Consistency: Ensure that the state-saving and loading functions are consistent with the internal representation of the model. Any changes in the model structure will require updates to these functions.

2. Validation: Thoroughly test the save and load functions to ensure that the model state is correctly restored. This includes checking that the simulation continues seamlessly after loading a state.

3. Performance: Depending on the size of the state data, saving and loading might impact performance. Optimize the serialization process if necessary.

Above steps will give you an approach to create a robust mechanism to save and reload the state of your Simulink code-generated model, allowing you to restart simulations from specific checkpoints.

Thank you.