Model Exchange FMI 2.0 Integration in PSCAD

[victor96ss]

I am using an FMI 2.0 Model Exchange FMU exported from Simulink R2024b. I serialize the FMU state using fmi2GetFMUstate and fmi2SerializeFMUstate, and later restore it using fmi2DeSerializeFMUstate and fmi2SetFMUstate.

This works correctly for a simple FMU, but not for a more complex one. After restoring the state, the simulation breaks, even though the inputs are identical.

I have verified that the serialized state is restored successfully (all FMI functions return fmi2OK), and the same wrapper code works with another FMU.

Has anyone experienced a similar issue with Simulink-generated Model Exchange FMUs? Are there any known limitations regarding state serialization/restoration, persistent variables, or additional FMI calls required after fmi2SetFMUstate?

Thank you very much in advance.

Best regards,

Victor Sanchez Suarez

I copy and paste the C-code I use to integrate the FMU:

// Begin of DllLink_C

#define REAL(param) double * param
#define INTEGER(param) int * param
#define COMPLEX(param) FCmplx * param
#define LOGICAL(param) int * param
#define REAL_ARR(param) double param[]
#define INTEGER_ARR(param) int param[]
#define COMPLEX_ARR(param) FCmplx param[]
#define LOGICAL_ARR(param) int param[]
#define FUNCTION(func_name) func_name
typedef struct { double real; double imag; } FCmplx;

// Dependencies
#include <Windows.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include "fmi2FunctionTypes.h"

#define INSTANTIATION_TOKEN "{fc0f3c22-5a57-47b4-cf5a-df1b4f4ff486}"
static const fmi2Real stepSize = 8.000000000000001e-05;

#define MAX_INSTANCES 1000

/* Inputs Value References type: fmi2ValueReference */
static const fmi2ValueReference vr_P[1] = { 0 };
static const fmi2ValueReference vr_idc[1] = { 1 };
static const fmi2ValueReference vr_Q[1] = { 2 };
static const fmi2ValueReference vr_Vpu[1] = { 3 };
static const fmi2ValueReference vr_PF[1] = { 4 };
static const fmi2ValueReference vr_deltaVpu[1] = { 5 };
static const fmi2ValueReference vr_deltaf[1] = { 6 };
static const fmi2ValueReference vr_deltaUpu[1] = { 7 };
static const fmi2ValueReference vr_PdroopK[1] = { 8 };
static const fmi2ValueReference vr_QdroopK[1] = { 9 };
static const fmi2ValueReference vr_P0[1] = { 10 };
static const fmi2ValueReference vr_Q0[1] = { 11 };
static const fmi2ValueReference vr_ZeroInjectionRef[1] = { 12 };
static const fmi2ValueReference vr_PWM_Main[1] = { 13 };
static const fmi2ValueReference vr_PWM_Aux[1] = { 14 };
static const fmi2ValueReference vr_CTRL[1] = { 15 };
static const fmi2ValueReference vr_PLL[1] = { 16 };
static const fmi2ValueReference vr_SYNC[1] = { 17 };
static const fmi2ValueReference vr_FOLLOW[1] = { 18 };
static const fmi2ValueReference vr_QMODE[1] = { 19 };
static const fmi2ValueReference vr_chg_fbd[1] = { 20 };
static const fmi2ValueReference vr_dchg_fbd[1] = { 21 };
static const fmi2ValueReference vr_PMODE[1] = { 22 };
static const fmi2ValueReference vr_ZI[1] = { 23 };
static const fmi2ValueReference vr_ZI_COMMS_LOST[1] = { 24 };
static const fmi2ValueReference vr_STUDY[1] = { 25 };
static const fmi2ValueReference vr_K1[1] = { 26 };
static const fmi2ValueReference vr_K2[1] = { 27 };
static const fmi2ValueReference vr_T_IGBT1[1] = { 28 };
static const fmi2ValueReference vr_T_IGBT2[1] = { 29 };
static const fmi2ValueReference vr_T_trf[1] = { 30 };
static const fmi2ValueReference vr_Trf_High_T[1] = { 31 };
static const fmi2ValueReference vr_u2[3] = { 32, 33, 34 };
static const fmi2ValueReference vr_iC[3] = { 35, 36, 37 };
static const fmi2ValueReference vr_i1[3] = { 38, 39, 40 };
static const fmi2ValueReference vr_i3[3] = { 41, 42, 43 };
static const fmi2ValueReference vr_udc[1] = { 44 };
static const fmi2ValueReference vr_idc1[1] = { 45 };
static const fmi2ValueReference vr_uSyncExt[3] = { 46, 47, 48 };
static const fmi2ValueReference vr_uSyncInt[3] = { 49, 50, 51 };
static const fmi2ValueReference vr_iNeutral[1] = { 52 };
static const fmi2ValueReference vr_uUPS[1] = { 53 };
static const fmi2ValueReference vr_iG[3] = { 54, 55, 56 };

/* Sizes of Inputs */
size_t size_P = 1;
size_t size_idc = 1;
size_t size_Q = 1;
size_t size_Vpu = 1;
size_t size_PF = 1;
size_t size_deltaVpu = 1;
size_t size_deltaf = 1;
size_t size_deltaUpu = 1;
size_t size_PdroopK = 1;
size_t size_QdroopK = 1;
size_t size_P0 = 1;
size_t size_Q0 = 1;
size_t size_ZeroInjectionRef = 1;
size_t size_PWM_Main = 1;
size_t size_PWM_Aux = 1;
size_t size_CTRL = 1;
size_t size_PLL = 1;
size_t size_SYNC = 1;
size_t size_FOLLOW = 1;
size_t size_QMODE = 1;
size_t size_chg_fbd = 1;
size_t size_dchg_fbd = 1;
size_t size_PMODE = 1;
size_t size_ZI = 1;
size_t size_ZI_COMMS_LOST = 1;
size_t size_STUDY = 1;
size_t size_K1 = 1;
size_t size_K2 = 1;
size_t size_T_IGBT1 = 1;
size_t size_T_IGBT2 = 1;
size_t size_T_trf = 1;
size_t size_Trf_High_T = 1;
size_t size_u2 = 3;
size_t size_iC = 3;
size_t size_i1 = 3;
size_t size_i3 = 3;
size_t size_udc = 1;
size_t size_idc1 = 1;
size_t size_uSyncExt = 3;
size_t size_uSyncInt = 3;
size_t size_iNeutral = 1;
size_t size_uUPS = 1;
size_t size_iG = 3;

/* Outputs Value References type: fmi2ValueReference */
static const fmi2ValueReference vr_GatesMain[3] = { 57, 58, 59 };
static const fmi2ValueReference vr_GatesAux[3] = { 60, 61, 62 };

/* Sizes of Outputs */
size_t size_GatesMain = 3;
size_t size_GatesAux = 3;

typedef struct
{
fmi2InstantiateTYPE* Instantiate;
fmi2SetupExperimentTYPE* SetupExperiment;
fmi2EnterInitializationModeTYPE* EnterInitializationMode;
fmi2ExitInitializationModeTYPE* ExitInitializationMode;
fmi2SetTimeTYPE* SetTime;
fmi2SetRealTYPE* SetReal;
fmi2GetRealTYPE* GetReal;
fmi2TerminateTYPE* Terminate;
fmi2FreeInstanceTYPE* FreeInstance;
fmi2GetFMUstateTYPE* GetFMUstate;
fmi2SetFMUstateTYPE* SetFMUstate;
fmi2FreeFMUstateTYPE* FreeFMUstate;
fmi2SerializedFMUstateSizeTYPE* SerializedFMUstateSize;
fmi2SerializeFMUstateTYPE* SerializeFMUstate;
fmi2DeSerializeFMUstateTYPE* DeSerializeFMUstate;
fmi2EnterEventModeTYPE* EnterEventMode;
fmi2NewDiscreteStatesTYPE* NewDiscreteStates;
fmi2EnterContinuousTimeModeTYPE* EnterContinuousTimeMode;
} FMUFunctions;

typedef struct
{
HMODULE libraryHandle;

fmi2Component instance;

fmi2Real time;

double nextEventTime;

FMUFunctions fmi;

} FMUInstance;

static FMUInstance instances[MAX_INSTANCES];

static FMUInstance* getContext(int instanceId)
{
if (instanceId < 0 || instanceId >= MAX_INSTANCES)
{
fprintf(stderr, "Invalid FMU instance %d\n", instanceId);
return NULL;
}

return &instances[instanceId];

}

static void cb_logMessage(
fmi2ComponentEnvironment componentEnvironment,
fmi2String instanceName,
fmi2Status status,
fmi2String category,
fmi2String message,
...)
{
if (!message) return;

char buf[1024];
va_list ap;
va_start(ap, message);
vsnprintf(buf, sizeof(buf), message, ap);
va_end(ap);

if (instanceName)
    fprintf(stderr, "FMU[%s] (%d) %s: %s\n", instanceName, (int)status, category ? category : "", buf);
else
    fprintf(stderr, "FMU (status=%d) %s\n", (int)status, buf);

}

static void* cb_allocateMemory(size_t nobj, size_t size)
{
return calloc(nobj, size);
}

static void cb_freeMemory(void* obj)
{
free(obj);
}

static void loadFMU(FMUInstance* ctx)
{
if (ctx->libraryHandle != NULL)
{
return;
}

ctx->libraryHandle = LoadLibraryA("nGM_unified_PF_EMT.dll");
if (!ctx->libraryHandle) {
    fprintf(stderr, "LoadLibrary failed (%lu)\n", (unsigned long)GetLastError());
    return;
}

#define LOAD_FMI_FUNC(name) ctx->fmi.name = (fmi2##name##TYPE*)GetProcAddress(ctx->libraryHandle, "fmi2" #name);

LOAD_FMI_FUNC(Instantiate)
LOAD_FMI_FUNC(SetupExperiment)
LOAD_FMI_FUNC(EnterInitializationMode)
LOAD_FMI_FUNC(ExitInitializationMode)
LOAD_FMI_FUNC(SetTime)
LOAD_FMI_FUNC(SetReal)
LOAD_FMI_FUNC(GetReal)
LOAD_FMI_FUNC(Terminate)
LOAD_FMI_FUNC(FreeInstance)
LOAD_FMI_FUNC(GetFMUstate)
LOAD_FMI_FUNC(SetFMUstate)
LOAD_FMI_FUNC(FreeFMUstate)
LOAD_FMI_FUNC(SerializedFMUstateSize)
LOAD_FMI_FUNC(SerializeFMUstate)
LOAD_FMI_FUNC(DeSerializeFMUstate)
LOAD_FMI_FUNC(EnterEventMode)
LOAD_FMI_FUNC(NewDiscreteStates)
LOAD_FMI_FUNC(EnterContinuousTimeMode)

#undef LOAD_FMI_FUNC

if (!ctx->fmi.Instantiate ||
    !ctx->fmi.SetupExperiment ||
    !ctx->fmi.EnterInitializationMode ||
    !ctx->fmi.ExitInitializationMode ||
    !ctx->fmi.SetTime ||
    !ctx->fmi.SetReal ||
    !ctx->fmi.GetReal ||
    !ctx->fmi.Terminate ||
    !ctx->fmi.FreeInstance ||
    !ctx->fmi.GetFMUstate ||
    !ctx->fmi.SetFMUstate ||
    !ctx->fmi.FreeFMUstate ||
    !ctx->fmi.SerializedFMUstateSize ||
    !ctx->fmi.SerializeFMUstate ||
    !ctx->fmi.DeSerializeFMUstate ||
    !ctx->fmi.EnterEventMode ||
    !ctx->fmi.NewDiscreteStates)
{
    fprintf(stderr, "Missing one or more required FMI 2.0 symbols\n");
    return;
}

if (ctx->instance) return;

fmi2CallbackFunctions callbacks = {
    cb_logMessage,
    cb_allocateMemory,
    cb_freeMemory,
    NULL,
    NULL
};

ctx->instance = ctx->fmi.Instantiate(
    "instance",
    fmi2ModelExchange,
    INSTANTIATION_TOKEN,
    NULL,
    &callbacks,
    fmi2False,
    fmi2False);

if (!ctx->instance) {
    printf("Instantiate failed\n");
    return;
}

}

static void init
(
FMUInstance* ctx,
double* P, // P
double* idc, // idc
double* Q, // Q
double* Vpu, // Vpu
double* PF, // PF
double* deltaVpu, // deltaVpu
double* deltaf, // deltaf
double* deltaUpu, // deltaUpu
double* PdroopK, // PdroopK
double* QdroopK, // QdroopK
double* P0, // P0
double* Q0, // Q0
double* ZeroInjectionRef, // ZeroInjectionRef
double* PWM_Main, // PWM_Main
double* PWM_Aux, // PWM_Aux
double* CTRL, // CTRL
double* PLL, // PLL
double* SYNC, // SYNC
double* FOLLOW, // FOLLOW
double* QMODE, // QMODE
double* chg_fbd, // chg_fbd
double* dchg_fbd, // dchg_fbd
double* PMODE, // PMODE
double* ZI, // ZI
double* ZI_COMMS_LOST, // ZI_COMMS_LOST
double* STUDY, // STUDY
double* K1, // K1
double* K2, // K2
double* T_IGBT1, // T_IGBT1
double* T_IGBT2, // T_IGBT2
double* T_trf, // T_trf
double* Trf_High_T, // Trf_High_T
double u2[3], // u2
double iC[3], // iC
double i1[3], // i1
double i3[3], // i3
double* udc, // udc
double* idc1, // idc1
double uSyncExt[3], // uSyncExt
double uSyncInt[3], // uSyncInt
double* iNeutral, // iNeutral
double* uUPS, // uUPS
double iG[3] // iG
)
{
if (!ctx->instance) return;

fmi2EventInfo eventInfo;

ctx->time = 0.0;

ctx->fmi.SetupExperiment(ctx->instance, fmi2False, 0.0, ctx->time, fmi2False, 0.0);

ctx->fmi.EnterInitializationMode(ctx->instance);

ctx->fmi.SetTime(ctx->instance, ctx->time);

ctx->fmi.SetReal(ctx->instance, vr_P,    size_P,   P);
ctx->fmi.SetReal(ctx->instance, vr_idc,    size_idc,   idc);
ctx->fmi.SetReal(ctx->instance, vr_Q,    size_Q,   Q);
ctx->fmi.SetReal(ctx->instance, vr_Vpu,    size_Vpu,   Vpu);
ctx->fmi.SetReal(ctx->instance, vr_PF,    size_PF,   PF);
ctx->fmi.SetReal(ctx->instance, vr_deltaVpu,    size_deltaVpu,   deltaVpu);
ctx->fmi.SetReal(ctx->instance, vr_deltaf,    size_deltaf,   deltaf);
ctx->fmi.SetReal(ctx->instance, vr_deltaUpu,    size_deltaUpu,   deltaUpu);
ctx->fmi.SetReal(ctx->instance, vr_PdroopK,    size_PdroopK,   PdroopK);
ctx->fmi.SetReal(ctx->instance, vr_QdroopK,    size_QdroopK,   QdroopK);
ctx->fmi.SetReal(ctx->instance, vr_P0,    size_P0,   P0);
ctx->fmi.SetReal(ctx->instance, vr_Q0,    size_Q0,   Q0);
ctx->fmi.SetReal(ctx->instance, vr_ZeroInjectionRef,    size_ZeroInjectionRef,   ZeroInjectionRef);
ctx->fmi.SetReal(ctx->instance, vr_PWM_Main,    size_PWM_Main,   PWM_Main);
ctx->fmi.SetReal(ctx->instance, vr_PWM_Aux,    size_PWM_Aux,   PWM_Aux);
ctx->fmi.SetReal(ctx->instance, vr_CTRL,    size_CTRL,   CTRL);
ctx->fmi.SetReal(ctx->instance, vr_PLL,    size_PLL,   PLL);
ctx->fmi.SetReal(ctx->instance, vr_SYNC,    size_SYNC,   SYNC);
ctx->fmi.SetReal(ctx->instance, vr_FOLLOW,    size_FOLLOW,   FOLLOW);
ctx->fmi.SetReal(ctx->instance, vr_QMODE,    size_QMODE,   QMODE);
ctx->fmi.SetReal(ctx->instance, vr_chg_fbd,    size_chg_fbd,   chg_fbd);
ctx->fmi.SetReal(ctx->instance, vr_dchg_fbd,    size_dchg_fbd,   dchg_fbd);
ctx->fmi.SetReal(ctx->instance, vr_PMODE,    size_PMODE,   PMODE);
ctx->fmi.SetReal(ctx->instance, vr_ZI,    size_ZI,   ZI);
ctx->fmi.SetReal(ctx->instance, vr_ZI_COMMS_LOST,    size_ZI_COMMS_LOST,   ZI_COMMS_LOST);
ctx->fmi.SetReal(ctx->instance, vr_STUDY,    size_STUDY,   STUDY);
ctx->fmi.SetReal(ctx->instance, vr_K1,    size_K1,   K1);
ctx->fmi.SetReal(ctx->instance, vr_K2,    size_K2,   K2);
ctx->fmi.SetReal(ctx->instance, vr_T_IGBT1,    size_T_IGBT1,   T_IGBT1);
ctx->fmi.SetReal(ctx->instance, vr_T_IGBT2,    size_T_IGBT2,   T_IGBT2);
ctx->fmi.SetReal(ctx->instance, vr_T_trf,    size_T_trf,   T_trf);
ctx->fmi.SetReal(ctx->instance, vr_Trf_High_T,    size_Trf_High_T,   Trf_High_T);
ctx->fmi.SetReal(ctx->instance, vr_u2,    size_u2,   u2);
ctx->fmi.SetReal(ctx->instance, vr_iC,    size_iC,   iC);
ctx->fmi.SetReal(ctx->instance, vr_i1,    size_i1,   i1);
ctx->fmi.SetReal(ctx->instance, vr_i3,    size_i3,   i3);
ctx->fmi.SetReal(ctx->instance, vr_udc,    size_udc,   udc);
ctx->fmi.SetReal(ctx->instance, vr_idc1,    size_idc1,   idc1);
ctx->fmi.SetReal(ctx->instance, vr_uSyncExt,    size_uSyncExt,   uSyncExt);
ctx->fmi.SetReal(ctx->instance, vr_uSyncInt,    size_uSyncInt,   uSyncInt);
ctx->fmi.SetReal(ctx->instance, vr_iNeutral,    size_iNeutral,   iNeutral);
ctx->fmi.SetReal(ctx->instance, vr_uUPS,    size_uUPS,   uUPS);
ctx->fmi.SetReal(ctx->instance, vr_iG,    size_iG,   iG);

ctx->fmi.ExitInitializationMode(ctx->instance);

ctx->fmi.EnterEventMode(ctx->instance);

ctx->fmi.NewDiscreteStates(ctx->instance, &eventInfo);

ctx->fmi.EnterContinuousTimeMode(ctx->instance);

ctx->nextEventTime = eventInfo.nextEventTime;

}

static void step
(
FMUInstance* ctx,
// --- INPUTS ---
double* P, // P
double* idc, // idc
double* Q, // Q
double* Vpu, // Vpu
double* PF, // PF
double* deltaVpu, // deltaVpu
double* deltaf, // deltaf
double* deltaUpu, // deltaUpu
double* PdroopK, // PdroopK
double* QdroopK, // QdroopK
double* P0, // P0
double* Q0, // Q0
double* ZeroInjectionRef, // ZeroInjectionRef
double* PWM_Main, // PWM_Main
double* PWM_Aux, // PWM_Aux
double* CTRL, // CTRL
double* PLL, // PLL
double* SYNC, // SYNC
double* FOLLOW, // FOLLOW
double* QMODE, // QMODE
double* chg_fbd, // chg_fbd
double* dchg_fbd, // dchg_fbd
double* PMODE, // PMODE
double* ZI, // ZI
double* ZI_COMMS_LOST, // ZI_COMMS_LOST
double* STUDY, // STUDY
double* K1, // K1
double* K2, // K2
double* T_IGBT1, // T_IGBT1
double* T_IGBT2, // T_IGBT2
double* T_trf, // T_trf
double* Trf_High_T, // Trf_High_T
double u2[3], // u2
double iC[3], // iC
double i1[3], // i1
double i3[3], // i3
double* udc, // udc
double* idc1, // idc1
double uSyncExt[3], // uSyncExt
double uSyncInt[3], // uSyncInt
double* iNeutral, // iNeutral
double* uUPS, // uUPS
double iG[3], // iG
// --- OUTPUTS ---
double GatesMain[3], // GatesMain
double GatesAux[3] // GatesAux
)
{
if (!ctx->instance) return;

fmi2EventInfo eventInfo;

ctx->fmi.SetTime(ctx->instance, ctx->nextEventTime);

ctx->fmi.SetReal(ctx->instance, vr_P, size_P, P);
ctx->fmi.SetReal(ctx->instance, vr_idc, size_idc, idc);
ctx->fmi.SetReal(ctx->instance, vr_Q, size_Q, Q);
ctx->fmi.SetReal(ctx->instance, vr_Vpu, size_Vpu, Vpu);
ctx->fmi.SetReal(ctx->instance, vr_PF, size_PF, PF);
ctx->fmi.SetReal(ctx->instance, vr_deltaVpu, size_deltaVpu, deltaVpu);
ctx->fmi.SetReal(ctx->instance, vr_deltaf, size_deltaf, deltaf);
ctx->fmi.SetReal(ctx->instance, vr_deltaUpu, size_deltaUpu, deltaUpu);
ctx->fmi.SetReal(ctx->instance, vr_PdroopK, size_PdroopK, PdroopK);
ctx->fmi.SetReal(ctx->instance, vr_QdroopK, size_QdroopK, QdroopK);
ctx->fmi.SetReal(ctx->instance, vr_P0, size_P0, P0);
ctx->fmi.SetReal(ctx->instance, vr_Q0, size_Q0, Q0);
ctx->fmi.SetReal(ctx->instance, vr_ZeroInjectionRef, size_ZeroInjectionRef, ZeroInjectionRef);
ctx->fmi.SetReal(ctx->instance, vr_PWM_Main, size_PWM_Main, PWM_Main);
ctx->fmi.SetReal(ctx->instance, vr_PWM_Aux, size_PWM_Aux, PWM_Aux);
ctx->fmi.SetReal(ctx->instance, vr_CTRL, size_CTRL, CTRL);
ctx->fmi.SetReal(ctx->instance, vr_PLL, size_PLL, PLL);
ctx->fmi.SetReal(ctx->instance, vr_SYNC, size_SYNC, SYNC);
ctx->fmi.SetReal(ctx->instance, vr_FOLLOW, size_FOLLOW, FOLLOW);
ctx->fmi.SetReal(ctx->instance, vr_QMODE, size_QMODE, QMODE);
ctx->fmi.SetReal(ctx->instance, vr_chg_fbd, size_chg_fbd, chg_fbd);
ctx->fmi.SetReal(ctx->instance, vr_dchg_fbd, size_dchg_fbd, dchg_fbd);
ctx->fmi.SetReal(ctx->instance, vr_PMODE, size_PMODE, PMODE);
ctx->fmi.SetReal(ctx->instance, vr_ZI, size_ZI, ZI);
ctx->fmi.SetReal(ctx->instance, vr_ZI_COMMS_LOST, size_ZI_COMMS_LOST, ZI_COMMS_LOST);
ctx->fmi.SetReal(ctx->instance, vr_STUDY, size_STUDY, STUDY);
ctx->fmi.SetReal(ctx->instance, vr_K1, size_K1, K1);
ctx->fmi.SetReal(ctx->instance, vr_K2, size_K2, K2);
ctx->fmi.SetReal(ctx->instance, vr_T_IGBT1, size_T_IGBT1, T_IGBT1);
ctx->fmi.SetReal(ctx->instance, vr_T_IGBT2, size_T_IGBT2, T_IGBT2);
ctx->fmi.SetReal(ctx->instance, vr_T_trf, size_T_trf, T_trf);
ctx->fmi.SetReal(ctx->instance, vr_Trf_High_T, size_Trf_High_T, Trf_High_T);
ctx->fmi.SetReal(ctx->instance, vr_u2, size_u2, u2);
ctx->fmi.SetReal(ctx->instance, vr_iC, size_iC, iC);
ctx->fmi.SetReal(ctx->instance, vr_i1, size_i1, i1);
ctx->fmi.SetReal(ctx->instance, vr_i3, size_i3, i3);
ctx->fmi.SetReal(ctx->instance, vr_udc, size_udc, udc);
ctx->fmi.SetReal(ctx->instance, vr_idc1, size_idc1, idc1);
ctx->fmi.SetReal(ctx->instance, vr_uSyncExt, size_uSyncExt, uSyncExt);
ctx->fmi.SetReal(ctx->instance, vr_uSyncInt, size_uSyncInt, uSyncInt);
ctx->fmi.SetReal(ctx->instance, vr_iNeutral, size_iNeutral, iNeutral);
ctx->fmi.SetReal(ctx->instance, vr_uUPS, size_uUPS, uUPS);
ctx->fmi.SetReal(ctx->instance, vr_iG, size_iG, iG);

ctx->fmi.EnterEventMode(ctx->instance);

do { ctx->fmi.NewDiscreteStates(ctx->instance, &eventInfo); } while (eventInfo.newDiscreteStatesNeeded);

ctx->fmi.EnterContinuousTimeMode(ctx->instance);

ctx->fmi.GetReal(ctx->instance, vr_GatesMain, size_GatesMain, GatesMain);
ctx->fmi.GetReal(ctx->instance, vr_GatesAux, size_GatesAux, GatesAux);

ctx->nextEventTime = eventInfo.nextEventTime;

ctx->time += stepSize;

}

static void param(FMUInstance* ctx, int* code, double* value, int* valueSize)
{
if (!ctx->instance || !code || !value || !valueSize || *valueSize <= 0) return;

size_t nvr = (size_t)(*valueSize);
fmi2ValueReference* vr = (fmi2ValueReference*)malloc(nvr * sizeof(*vr));

if (!vr) {
    fprintf(stderr, "Memory allocation error in param()\n");
    return;
}

for (size_t i = 0; i < nvr; ++i) {
    vr[i] = (fmi2ValueReference)(*code + (int)i);
}

ctx->fmi.SetReal(ctx->instance, vr, nvr, value);
free(vr);

}

static void save(FMUInstance* ctx, fmi2Byte* buffer, size_t maxSize)
{
fmi2FMUstate state = NULL;
size_t stateSize;
uint32_t size32;

ctx->fmi.GetFMUstate(ctx->instance, &state);

ctx->fmi.SerializedFMUstateSize(ctx->instance, state, &stateSize);

if (sizeof(uint32_t) + stateSize > maxSize)
{
    fprintf(stderr, "Snapshot buffer too small (%u bytes required)\n", (unsigned int)(sizeof(uint32_t) + stateSize));

    ctx->fmi.FreeFMUstate(ctx->instance, &state);
    return;
}

size32 = (uint32_t)stateSize;

memcpy(buffer, &size32, sizeof(size32));

ctx->fmi.SerializeFMUstate(ctx->instance, state, buffer + sizeof(uint32_t), stateSize);

ctx->fmi.FreeFMUstate(ctx->instance, &state);

}

static void restore(FMUInstance* ctx, const fmi2Byte* buffer)
{
fmi2FMUstate state = NULL;
uint32_t stateSize;

memcpy(&stateSize, buffer, sizeof(stateSize));

ctx->fmi.DeSerializeFMUstate(ctx->instance, buffer + sizeof(uint32_t), stateSize, &state);

ctx->fmi.SetFMUstate(ctx->instance, state);

ctx->fmi.SetTime(ctx->instance, ctx->time);

ctx->fmi.FreeFMUstate(ctx->instance, &state);

}

static void terminate(FMUInstance* ctx)
{
if (ctx->instance)
{
fmi2Status status = ctx->fmi.Terminate(ctx->instance);

    if (status != fmi2OK && status != fmi2Warning)
    {
        fprintf(stderr, "Terminate failed (status=%d)\n", (int)status);
    }

    ctx->fmi.FreeInstance(ctx->instance);
    ctx->instance = NULL;
}

if (ctx->libraryHandle)
{
    FreeLibrary(ctx->libraryHandle);
    ctx->libraryHandle = NULL;
}

}

// --------------------------------------------------------------------------------------
// This enumerable is used to indicate how the structure should be read from the storage
// --------------------------------------------------------------------------------------
enum StatusTypes
{
INITIALIZE = 0,
FINALIZE = 1,
SERIALIZE = 2,
DESERIALIZE = 3,
NORMAL = 4
};

void FUNCTION(func_main)(REAL(P), REAL(idc), REAL(Q), REAL(Vpu), REAL(PF), REAL(deltaVpu), REAL(deltaf), REAL(deltaUpu), REAL(PdroopK), REAL(QdroopK), REAL(P0), REAL(Q0), REAL(ZeroInjectionRef), REAL(PWM_Main), REAL(PWM_Aux), REAL(CTRL), REAL(PLL), REAL(SYNC), REAL(FOLLOW), REAL(QMODE), REAL(chg_fbd), REAL(dchg_fbd), REAL(PMODE), REAL(ZI), REAL(ZI_COMMS_LOST), REAL(STUDY), REAL(K1), REAL(K2), REAL(T_IGBT1), REAL(T_IGBT2), REAL(T_trf), REAL(Trf_High_T), REAL(u2), REAL(iC), REAL(i1), REAL(i3), REAL(udc), REAL(idc1), REAL(uSyncExt), REAL(uSyncInt), REAL(iNeutral), REAL(uUPS), REAL(iG), REAL(GatesMain), REAL(GatesAux), INTEGER(INSTANCE_ID), INTEGER(STATUS), INTEGER(RUNCTRL), INTEGER(NSTORI), INTEGER_ARR(STORI))
{
void *buffer;

const int BUFFER_SIZE = 43749;

int nstori = *NSTORI - 1;

FMUInstance* ctx = getContext(*INSTANCE_ID);

if (!ctx)
return;

buffer = (void*)(&(STORI[nstori]));

if (*STATUS == INITIALIZE)
{
init(ctx, P, idc, Q, Vpu, PF, deltaVpu, deltaf, deltaUpu, PdroopK, QdroopK, P0, Q0, ZeroInjectionRef, PWM_Main, PWM_Aux, CTRL, PLL, SYNC, FOLLOW, QMODE, chg_fbd, dchg_fbd, PMODE, ZI, ZI_COMMS_LOST, STUDY, K1, K2, T_IGBT1, T_IGBT2, T_trf, Trf_High_T, u2, iC, i1, i3, udc, idc1, uSyncExt, uSyncInt, iNeutral, uUPS, iG);
}
else if (STATUS == DESERIALIZE)
{
restore(ctx, (const fmi2Byte)buffer);
}

if (*RUNCTRL) { step(ctx, P, idc, Q, Vpu, PF, deltaVpu, deltaf, deltaUpu, PdroopK, QdroopK, P0, Q0, ZeroInjectionRef, PWM_Main, PWM_Aux, CTRL, PLL, SYNC, FOLLOW, QMODE, chg_fbd, dchg_fbd, PMODE, ZI, ZI_COMMS_LOST, STUDY, K1, K2, T_IGBT1, T_IGBT2, T_trf, Trf_High_T, u2, iC, i1, i3, udc, idc1, uSyncExt, uSyncInt, iNeutral, uUPS, iG, GatesMain, GatesAux); }

if (*STATUS == FINALIZE)
{
terminate(ctx);
}
else if (STATUS == SERIALIZE)
{
save(ctx, (fmi2Byte)buffer, BUFFER_SIZE * sizeof(int));
}

(*NSTORI) += BUFFER_SIZE;
}

// ------------------------------------------------------------
// C wrapper called from Fortran: LOADFMU
// ------------------------------------------------------------
void FUNCTION(func_load)(INTEGER(INSTANCE_ID))
{
FMUInstance* ctx = getContext(*INSTANCE_ID);

if (!ctx)
    return;

loadFMU(ctx);

}

// ------------------------------------------------------------
// C wrapper called from Fortran: PARAM
// ------------------------------------------------------------
void FUNCTION(func_param)(INTEGER(INSTANCE_ID), INTEGER(code), REAL(newvalue), INTEGER(valueSize))
{
FMUInstance* ctx = getContext(*INSTANCE_ID);

if (!ctx)
    return;

param(ctx, code, newvalue, valueSize);

}

[chrbertsch]

You seem to test many different things at the same time: getting and setting the serialized FMU state for an FMU exported from Simulink, and an own implementation ...
I would recommend to test sequentially:

• first use a well known importer with get/set FMU state support, such as fmpy, see this test: https://github.com/CATIA-Systems/FMPy/blob/main/tests/test_fmu_state.py
• ask your Mathworks support, how they test the get/set FMU state functionality (as they seem to support only the export, right? But they must have tested the setting in some environment such as fmpy ...) @liweiwu : could you please comment?

[pmai]

I agree with @mohammadrezwankhan in that the current code base seems all over the place, to the point that any problems with the FMU - if any - would be masked by problems in the code itself.

Beside the problems already mentioned, there are various other basic issues:

• The init code calls fmi2SetTime in Initialization Mode. That is not an allowed (nor required) call in initialization mode. The time is already set via the call to fmi2SetupExperiment, and cannot be changed during initialization mode.

• FMI 2.x specifies that for a Model Exchange FMU, exiting initialization mode directly transitions to event mode, yet the init function performs:

  ctx->fmi.ExitInitializationMode(ctx->instance);
  
  ctx->fmi.EnterEventMode(ctx->instance);
  

  This already violates the FMI API, as fmi2EnterEventMode cannot be called in event mode. Furthermore the code then fails to properly handle event iteration (which is as needed for the event mode directly after exiting initialization mode, as it is for "normal" event mode).

Besides, since the intent seems to be to just step through the simulation, why not employ a co-simulation FMU, which Simulink is just as capable of producing, and which is much easier to handle with the basic approach the code seems to want to employ.

[victor96ss]

Thank you all very much for your detailed comments and suggestions. They were extremely helpful.

You were right that there were several important issues in my importer implementation. Your feedback helped me review the code, fix a number of mistakes, and end up with a much more robust implementation. In particular, I corrected the handling of nextEventTime, time, and some other importer-side state.

In the end, I managed to solve the problem. The root cause was actually inside the Simulink model I was exporting. An internal variable was not being initialized correctly, which led to inconsistent behavior after restoring the FMU state. Once that was fixed, state serialization and restoration worked correctly.

Regarding the Model Exchange implementation, my workflow does not use fmi2GetContinuousStates, fmi2GetDerivatives, fmi2SetContinuousStates, fmi2GetEventIndicators, or fmi2CompletedIntegratorStep because this particular model is purely discrete and contains no continuous states or continuous-time variables.

As for using a Co-Simulation FMU, that was actually one of my first approaches. Unfortunately, I encountered state management issues with Simulink-generated Co-Simulation FMUs, even when testing them within the Simulink environment itself. That is why I eventually decided to switch to Model Exchange.

Once again, thank you all for taking the time to help. The quality of the feedback has been excellent, and it greatly helped me identify and resolve the problem.

[mohammadrezwankhan]

Thanks for closing the loop. For future readers, the resolution was two-part:

1. Restore importer-owned state as well as FMU state. The wrapper must save and restore its simulation time, next-event time, and the corresponding nextEventTimeDefined flag alongside the serialized FMU bytes. It must also preserve the FMI 2.0 Model Exchange state-machine and event-iteration rules.
2. Initialize the model-owned state consistently. In this case, an internal variable in the exported Simulink model was not initialized correctly. That produced inconsistent behavior after an otherwise successful fmi2SetFMUstate. Correcting the initialization made serialization and restoration reproducible.

Because this particular FMU is purely discrete, a continuous-state integration loop is not required. Correct discrete-event handling and wrapper-state rollback are still required. The useful diagnostic sequence is therefore: first validate the FMU snapshot with an independent importer, then compare every importer-owned clock/event field across save and restore, and finally audit model initialization for state that is not deterministic at the restored point.